home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / amiga / gui / x / twm93053.lha / twm / menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-30  |  69.0 KB  |  2,961 lines
  1. /*****************************************************************************/
  2. /**       Copyright 1988 by Evans & Sutherland Computer Corporation,        **/
  3. /**                          Salt Lake City, Utah                           **/
  4. /**  Portions Copyright 1989 by the Massachusetts Institute of Technology   **/
  5. /**                        Cambridge, Massachusetts                         **/
  6. /**                                                                         **/
  7. /**                           All Rights Reserved                           **/
  8. /**                                                                         **/
  9. /**    Permission to use, copy, modify, and distribute this software and    **/
  10. /**    its documentation  for  any  purpose  and  without  fee is hereby    **/
  11. /**    granted, provided that the above copyright notice appear  in  all    **/
  12. /**    copies and that both  that  copyright  notice  and  this  permis-    **/
  13. /**    sion  notice appear in supporting  documentation,  and  that  the    **/
  14. /**    names of Evans & Sutherland and M.I.T. not be used in advertising    **/
  15. /**    in publicity pertaining to distribution of the  software  without    **/
  16. /**    specific, written prior permission.                                  **/
  17. /**                                                                         **/
  18. /**    EVANS & SUTHERLAND AND M.I.T. DISCLAIM ALL WARRANTIES WITH REGARD    **/
  19. /**    TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES  OF  MERCHANT-    **/
  20. /**    ABILITY  AND  FITNESS,  IN  NO  EVENT SHALL EVANS & SUTHERLAND OR    **/
  21. /**    M.I.T. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL  DAM-    **/
  22. /**    AGES OR  ANY DAMAGES WHATSOEVER  RESULTING FROM LOSS OF USE, DATA    **/
  23. /**    OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER    **/
  24. /**    TORTIOUS ACTION, ARISING OUT OF OR IN  CONNECTION  WITH  THE  USE    **/
  25. /**    OR PERFORMANCE OF THIS SOFTWARE.                                     **/
  26. /*****************************************************************************/
  27.  
  28.  
  29. /***********************************************************************
  30.  *
  31.  * $XConsortium: menus.c,v 1.186 91/07/17 13:58:00 dave Exp $
  32.  *
  33.  * twm menu code
  34.  *
  35.  * 17-Nov-87 Thomas E. LaStrange        File created
  36.  *
  37.  ***********************************************************************/
  38.  
  39. #include <stdio.h>
  40. #include <signal.h>
  41. #include <X11/Xos.h>
  42. #include "twm.h"
  43. #include "gc.h"
  44. #include "menus.h"
  45. #include "resize.h"
  46. #include "events.h"
  47. #include "util.h"
  48. #include "parse.h"
  49. #include "gram.h"
  50. #include "screen.h"
  51. #include <X11/Xmu/CharSet.h>
  52. #include <X11/bitmaps/menu12>
  53. #include "version.h"
  54.  
  55. extern XEvent Event;
  56.  
  57. int RootFunction = NULL;
  58. MenuRoot *ActiveMenu = NULL;        /* the active menu */
  59. MenuItem *ActiveItem = NULL;        /* the active menu item */
  60. int MoveFunction;            /* either F_MOVE or F_FORCEMOVE */
  61. int WindowMoved = FALSE;
  62. int menuFromFrameOrWindowOrTitlebar = FALSE;
  63.  
  64. int ConstMove = FALSE;        /* constrained move variables */
  65. int ConstMoveDir;
  66. int ConstMoveX;
  67. int ConstMoveY;
  68. int ConstMoveXL;
  69. int ConstMoveXR;
  70. int ConstMoveYT;
  71. int ConstMoveYB;
  72.  
  73. /* Globals used to keep track of whether the mouse has moved during
  74.    a resize function. */
  75. int ResizeOrigX;
  76. int ResizeOrigY;
  77.  
  78. int MenuDepth = 0;        /* number of menus up */
  79. static struct {
  80.     int x;
  81.     int y;
  82. } MenuOrigins[MAXMENUDEPTH];
  83. static Cursor LastCursor;
  84.  
  85. void WarpAlongRing(), WarpToWindow();
  86.  
  87. extern char *Action;
  88. extern int Context;
  89. extern TwmWindow *ButtonWindow, *Tmp_win;
  90. extern XEvent Event, ButtonEvent;
  91. extern char *InitFile;
  92. static void Identify();
  93.  
  94. #define SHADOWWIDTH 5            /* in pixels */
  95.  
  96.  
  97.  
  98. /***********************************************************************
  99.  *
  100.  *  Procedure:
  101.  *    InitMenus - initialize menu roots
  102.  *
  103.  ***********************************************************************
  104.  */
  105.  
  106. void
  107. InitMenus()
  108. {
  109.     int i, j, k;
  110.     FuncKey *key, *tmp;
  111.  
  112.     for (i = 0; i < MAX_BUTTONS+1; i++)
  113.     for (j = 0; j < NUM_CONTEXTS; j++)
  114.         for (k = 0; k < MOD_SIZE; k++)
  115.         {
  116.         Scr->Mouse[i][j][k].func = NULL;
  117.         Scr->Mouse[i][j][k].item = NULL;
  118.         }
  119.  
  120.     Scr->DefaultFunction.func = NULL;
  121.     Scr->WindowFunction.func = NULL;
  122.  
  123.     if (FirstScreen)
  124.     {
  125.     for (key = Scr->FuncKeyRoot.next; key != NULL;)
  126.     {
  127.         free(key->name);
  128.         tmp = key;
  129.         key = key->next;
  130.         free((char *) tmp);
  131.     }
  132.     Scr->FuncKeyRoot.next = NULL;
  133.     }
  134.  
  135. }
  136.  
  137.  
  138.  
  139. /***********************************************************************
  140.  *
  141.  *  Procedure:
  142.  *    AddFuncKey - add a function key to the list
  143.  *
  144.  *  Inputs:
  145.  *    name    - the name of the key
  146.  *    cont    - the context to look for the key press in
  147.  *    mods    - modifier keys that need to be pressed
  148.  *    func    - the function to perform
  149.  *    win_name- the window name (if any)
  150.  *    action    - the action string associated with the function (if any)
  151.  *
  152.  ***********************************************************************
  153.  */
  154.  
  155. Bool AddFuncKey (name, cont, mods, func, win_name, action)
  156.     char *name;
  157.     int cont, mods, func;
  158.     char *win_name;
  159.     char *action;
  160. {
  161.     FuncKey *tmp;
  162.     KeySym keysym;
  163.     KeyCode keycode;
  164.  
  165.     /*
  166.      * Don't let a 0 keycode go through, since that means AnyKey to the
  167.      * XGrabKey call in GrabKeys().
  168.      */
  169.     if ((keysym = XStringToKeysym(name)) == NoSymbol ||
  170.     (keycode = XKeysymToKeycode(dpy, keysym)) == 0)
  171.     {
  172.     return False;
  173.     }
  174.  
  175.     /* see if there already is a key defined for this context */
  176.     for (tmp = Scr->FuncKeyRoot.next; tmp != NULL; tmp = tmp->next)
  177.     {
  178.     if (tmp->keysym == keysym &&
  179.         tmp->cont == cont &&
  180.         tmp->mods == mods)
  181.         break;
  182.     }
  183.  
  184.     if (tmp == NULL)
  185.     {
  186.     tmp = (FuncKey *) malloc(sizeof(FuncKey));
  187.     tmp->next = Scr->FuncKeyRoot.next;
  188.     Scr->FuncKeyRoot.next = tmp;
  189.     }
  190.  
  191.     tmp->name = name;
  192.     tmp->keysym = keysym;
  193.     tmp->keycode = keycode;
  194.     tmp->cont = cont;
  195.     tmp->mods = mods;
  196.     tmp->func = func;
  197.     tmp->win_name = win_name;
  198.     tmp->action = action;
  199.  
  200.     return True;
  201. }
  202.  
  203.  
  204.  
  205. int CreateTitleButton (name, func, action, menuroot, rightside, append)
  206.     char *name;
  207.     int func;
  208.     char *action;
  209.     MenuRoot *menuroot;
  210.     Bool rightside;
  211.     Bool append;
  212. {
  213.     TitleButton *tb = (TitleButton *) malloc (sizeof(TitleButton));
  214.  
  215.     if (!tb) {
  216.     fprintf (stderr,
  217.          "%s:  unable to allocate %d bytes for title button\n",
  218.          ProgramName, sizeof(TitleButton));
  219.     return 0;
  220.     }
  221.  
  222.     tb->next = NULL;
  223.     tb->name = name;            /* note that we are not copying */
  224.     tb->bitmap = None;            /* WARNING, values not set yet */
  225.     tb->width = 0;            /* see InitTitlebarButtons */
  226.     tb->height = 0;            /* ditto */
  227.     tb->func = func;
  228.     tb->action = action;
  229.     tb->menuroot = menuroot;
  230.     tb->rightside = rightside;
  231.     if (rightside) {
  232.     Scr->TBInfo.nright++;
  233.     } else {
  234.     Scr->TBInfo.nleft++;
  235.     }
  236.  
  237.     /*
  238.      * Cases for list:
  239.      * 
  240.      *     1.  empty list, prepend left       put at head of list
  241.      *     2.  append left, prepend right     put in between left and right
  242.      *     3.  append right                   put at tail of list
  243.      *
  244.      * Do not refer to widths and heights yet since buttons not created
  245.      * (since fonts not loaded and heights not known).
  246.      */
  247.     if ((!Scr->TBInfo.head) || ((!append) && (!rightside))) {    /* 1 */
  248.     tb->next = Scr->TBInfo.head;
  249.     Scr->TBInfo.head = tb;
  250.     } else if (append && rightside) {    /* 3 */
  251.     register TitleButton *t;
  252.     for /* SUPPRESS 530 */
  253.       (t = Scr->TBInfo.head; t->next; t = t->next);
  254.     t->next = tb;
  255.     tb->next = NULL;
  256.     } else {                /* 2 */
  257.     register TitleButton *t, *prev = NULL;
  258.     for (t = Scr->TBInfo.head; t && !t->rightside; t = t->next) {
  259.         prev = t;
  260.     }
  261.     if (prev) {
  262.         tb->next = prev->next;
  263.         prev->next = tb;
  264.     } else {
  265.         tb->next = Scr->TBInfo.head;
  266.         Scr->TBInfo.head = tb;
  267.     }
  268.     }
  269.  
  270.     return 1;
  271. }
  272.  
  273.  
  274.  
  275. /*
  276.  * InitTitlebarButtons - Do all the necessary stuff to load in a titlebar
  277.  * button.  If we can't find the button, then put in a question; if we can't
  278.  * find the question mark, something is wrong and we are probably going to be
  279.  * in trouble later on.
  280.  */
  281. void InitTitlebarButtons ()
  282. {
  283.     TitleButton *tb;
  284.     int h;
  285.  
  286.     /*
  287.      * initialize dimensions
  288.      */
  289.     Scr->TBInfo.width = (Scr->TitleHeight -
  290.              2 * (Scr->FramePadding + Scr->ButtonIndent));
  291.     Scr->TBInfo.pad = ((Scr->TitlePadding > 1)
  292.                ? ((Scr->TitlePadding + 1) / 2) : 1);
  293.     h = Scr->TBInfo.width - 2 * Scr->TBInfo.border;
  294.  
  295.     /*
  296.      * add in some useful buttons and bindings so that novices can still
  297.      * use the system.
  298.      */
  299.     if (!Scr->NoDefaults) {
  300.     /* insert extra buttons */
  301.     if (!CreateTitleButton (TBPM_ICONIFY, F_ICONIFY, "", (MenuRoot *) NULL,
  302.                 False, False)) {
  303.         fprintf (stderr, "%s:  unable to add iconify button\n",
  304.              ProgramName);
  305.     }
  306.     if (!CreateTitleButton (TBPM_RESIZE, F_RESIZE, "", (MenuRoot *) NULL,
  307.                 True, True)) {
  308.         fprintf (stderr, "%s:  unable to add resize button\n",
  309.              ProgramName);
  310.     }
  311.     AddDefaultBindings ();
  312.     }
  313.     ComputeCommonTitleOffsets ();
  314.  
  315.     /*
  316.      * load in images and do appropriate centering
  317.      */
  318.  
  319.     for (tb = Scr->TBInfo.head; tb; tb = tb->next) {
  320.     tb->bitmap = FindBitmap (tb->name, &tb->width, &tb->height);
  321.     if (!tb->bitmap) {
  322.         tb->bitmap = FindBitmap (TBPM_QUESTION, &tb->width, &tb->height);
  323.         if (!tb->bitmap) {        /* cannot happen (see util.c) */
  324.         fprintf (stderr,
  325.              "%s:  unable to add titlebar button \"%s\"\n",
  326.              ProgramName, tb->name);
  327.         }
  328.     }
  329.  
  330.     tb->dstx = (h - tb->width + 1) / 2;
  331.     if (tb->dstx < 0) {        /* clip to minimize copying */
  332.         tb->srcx = -(tb->dstx);
  333.         tb->width = h;
  334.         tb->dstx = 0;
  335.     } else {
  336.         tb->srcx = 0;
  337.     }
  338.     tb->dsty = (h - tb->height + 1) / 2;
  339.     if (tb->dsty < 0) {
  340.         tb->srcy = -(tb->dsty);
  341.         tb->height = h;
  342.         tb->dsty = 0;
  343.     } else {
  344.         tb->srcy = 0;
  345.     }
  346.     }
  347. }
  348.  
  349.  
  350.  
  351. PaintEntry(mr, mi, exposure)
  352. MenuRoot *mr;
  353. MenuItem *mi;
  354. int exposure;
  355. {
  356.     int y_offset;
  357.     int text_y;
  358.     GC gc;
  359.  
  360. #ifdef DEBUG_MENUS
  361.     fprintf(stderr, "Paint entry\n");
  362. #endif
  363.     y_offset = mi->item_num * Scr->EntryHeight;
  364.     text_y = y_offset + Scr->MenuFont.y;
  365.  
  366.     if (mi->func != F_TITLE)
  367.     {
  368.     int x, y;
  369.  
  370.     if (mi->state)
  371.     {
  372.         XSetForeground(dpy, Scr->NormalGC, mi->hi_back);
  373.  
  374.         XFillRectangle(dpy, mr->w, Scr->NormalGC, 0, y_offset,
  375.         mr->width, Scr->EntryHeight);
  376.  
  377.         FBF(mi->hi_fore, mi->hi_back, Scr->MenuFont.font->fid);
  378.  
  379.         XDrawString(dpy, mr->w, Scr->NormalGC, mi->x,
  380.         text_y, mi->item, mi->strlen);
  381.  
  382.         gc = Scr->NormalGC;
  383.     }
  384.     else
  385.     {
  386.         if (mi->user_colors || !exposure)
  387.         {
  388.         XSetForeground(dpy, Scr->NormalGC, mi->back);
  389.  
  390.         XFillRectangle(dpy, mr->w, Scr->NormalGC, 0, y_offset,
  391.             mr->width, Scr->EntryHeight);
  392.  
  393.         FBF(mi->fore, mi->back, Scr->MenuFont.font->fid);
  394.         gc = Scr->NormalGC;
  395.         }
  396.         else
  397.         gc = Scr->MenuGC;
  398.  
  399.         XDrawString(dpy, mr->w, gc, mi->x,
  400.         text_y, mi->item, mi->strlen);
  401.     }
  402.  
  403.     if (mi->func == F_MENU)
  404.     {
  405.         /* create the pull right pixmap if needed */
  406.         if (Scr->pullPm == None)
  407.         {
  408.         Scr->pullPm = CreateMenuIcon (Scr->MenuFont.height,
  409.                          &Scr->pullW, &Scr->pullH);
  410.         }
  411.         x = mr->width - Scr->pullW - 5;
  412.         y = y_offset + ((Scr->MenuFont.height - Scr->pullH) / 2);
  413.         XCopyPlane(dpy, Scr->pullPm, mr->w, gc, 0, 0,
  414.         Scr->pullW, Scr->pullH, x, y, 1);
  415.     }
  416.     }
  417.     else
  418.     {
  419.     int y;
  420.  
  421.     XSetForeground(dpy, Scr->NormalGC, mi->back);
  422.  
  423.     /* fill the rectangle with the title background color */
  424.     XFillRectangle(dpy, mr->w, Scr->NormalGC, 0, y_offset,
  425.         mr->width, Scr->EntryHeight);
  426.  
  427.     {
  428.         XSetForeground(dpy, Scr->NormalGC, mi->fore);
  429.         /* now draw the dividing lines */
  430.         if (y_offset)
  431.           XDrawLine (dpy, mr->w, Scr->NormalGC, 0, y_offset,
  432.              mr->width, y_offset);
  433.         y = ((mi->item_num+1) * Scr->EntryHeight)-1;
  434.         XDrawLine(dpy, mr->w, Scr->NormalGC, 0, y, mr->width, y);
  435.     }
  436.  
  437.     FBF(mi->fore, mi->back, Scr->MenuFont.font->fid);
  438.     /* finally render the title */
  439.     XDrawString(dpy, mr->w, Scr->NormalGC, mi->x,
  440.         text_y, mi->item, mi->strlen);
  441.     }
  442. }
  443.     
  444.  
  445.  
  446. PaintMenu(mr, e)
  447. MenuRoot *mr;
  448. XEvent *e;
  449. {
  450.     MenuItem *mi;
  451.  
  452.     for (mi = mr->first; mi != NULL; mi = mi->next)
  453.     {
  454.     int y_offset = mi->item_num * Scr->EntryHeight;
  455.  
  456.     /* be smart about handling the expose, redraw only the entries
  457.      * that we need to
  458.      */
  459.     if (e->xexpose.y < (y_offset + Scr->EntryHeight) &&
  460.         (e->xexpose.y + e->xexpose.height) > y_offset)
  461.     {
  462.         PaintEntry(mr, mi, True);
  463.     }
  464.     }
  465.     XSync(dpy, 0);
  466. }
  467.  
  468.  
  469.  
  470. static Bool fromMenu;
  471.  
  472. UpdateMenu()
  473. {
  474.     MenuItem *mi;
  475.     int i, x, y, x_root, y_root, entry;
  476.     int done;
  477.     MenuItem *badItem = NULL;
  478.  
  479.     fromMenu = TRUE;
  480.  
  481.     while (TRUE)
  482.     {
  483.     /* block until there is an event */
  484.         if (!menuFromFrameOrWindowOrTitlebar) {
  485.       XMaskEvent(dpy,
  486.              ButtonPressMask | ButtonReleaseMask |
  487.              EnterWindowMask | ExposureMask |
  488.              VisibilityChangeMask | LeaveWindowMask |
  489.              ButtonMotionMask, &Event);
  490.     }
  491.     if (Event.type == MotionNotify) {
  492.         /* discard any extra motion events before a release */
  493.         while(XCheckMaskEvent(dpy,
  494.         ButtonMotionMask | ButtonReleaseMask, &Event))
  495.         if (Event.type == ButtonRelease)
  496.             break;
  497.     }
  498.  
  499.     if (!DispatchEvent ())
  500.         continue;
  501.  
  502.     if (Event.type == ButtonRelease || Cancel) {
  503.       menuFromFrameOrWindowOrTitlebar = FALSE;
  504.       fromMenu = FALSE;
  505.       return;
  506.     }
  507.  
  508.     if (Event.type != MotionNotify)
  509.         continue;
  510.  
  511.     done = FALSE;
  512.     XQueryPointer( dpy, ActiveMenu->w, &JunkRoot, &JunkChild,
  513.         &x_root, &y_root, &x, &y, &JunkMask);
  514.  
  515.     /* if we haven't recieved the enter notify yet, wait */
  516.     if (ActiveMenu && !ActiveMenu->entered)
  517.         continue;
  518.  
  519.     XFindContext(dpy, ActiveMenu->w, ScreenContext, (caddr_t *)&Scr);
  520.  
  521.     if (x < 0 || y < 0 ||
  522.         x >= ActiveMenu->width || y >= ActiveMenu->height)
  523.     {
  524.         if (ActiveItem && ActiveItem->func != F_TITLE)
  525.         {
  526.         ActiveItem->state = 0;
  527.         PaintEntry(ActiveMenu, ActiveItem, False);
  528.         }
  529.         ActiveItem = NULL;
  530.         continue;
  531.     }
  532.  
  533.     /* look for the entry that the mouse is in */
  534.     entry = y / Scr->EntryHeight;
  535.     for (i = 0, mi = ActiveMenu->first; mi != NULL; i++, mi=mi->next)
  536.     {
  537.         if (i == entry)
  538.         break;
  539.     }
  540.  
  541.     /* if there is an active item, we might have to turn it off */
  542.     if (ActiveItem)
  543.     {
  544.         /* is the active item the one we are on ? */
  545.         if (ActiveItem->item_num == entry && ActiveItem->state)
  546.         done = TRUE;
  547.  
  548.         /* if we weren't on the active entry, let's turn the old
  549.          * active one off 
  550.          */
  551.         if (!done && ActiveItem->func != F_TITLE)
  552.         {
  553.         ActiveItem->state = 0;
  554.         PaintEntry(ActiveMenu, ActiveItem, False);
  555.         }
  556.     }
  557.  
  558.     /* if we weren't on the active item, change the active item and turn
  559.      * it on 
  560.      */
  561.     if (!done)
  562.     {
  563.         ActiveItem = mi;
  564.         if (ActiveItem->func != F_TITLE && !ActiveItem->state)
  565.         {
  566.         ActiveItem->state = 1;
  567.         PaintEntry(ActiveMenu, ActiveItem, False);
  568.         }
  569.     }
  570.  
  571.     /* now check to see if we were over the arrow of a pull right entry */
  572.     if (ActiveItem->func == F_MENU && 
  573.         ((ActiveMenu->width - x) < (ActiveMenu->width >> 1)))
  574.     {
  575.         MenuRoot *save = ActiveMenu;
  576.         int savex = MenuOrigins[MenuDepth - 1].x; 
  577.         int savey = MenuOrigins[MenuDepth - 1].y;
  578.  
  579.         if (MenuDepth < MAXMENUDEPTH) {
  580.         PopUpMenu (ActiveItem->sub, 
  581.                (savex + (ActiveMenu->width >> 1)), 
  582.                (savey + ActiveItem->item_num * Scr->EntryHeight)
  583.                /*(savey + ActiveItem->item_num * Scr->EntryHeight +
  584.                 (Scr->EntryHeight >> 1))*/, False);
  585.         } else if (!badItem) {
  586.         XBell (dpy, 0);
  587.         badItem = ActiveItem;
  588.         }
  589.  
  590.         /* if the menu did get popped up, unhighlight the active item */
  591.         if (save != ActiveMenu && ActiveItem->state)
  592.         {
  593.         ActiveItem->state = 0;
  594.         PaintEntry(save, ActiveItem, False);
  595.         ActiveItem = NULL;
  596.         }
  597.     }
  598.     if (badItem != ActiveItem) badItem = NULL;
  599.     XFlush(dpy);
  600.     }
  601.  
  602. }
  603.  
  604.  
  605.  
  606. /***********************************************************************
  607.  *
  608.  *  Procedure:
  609.  *    NewMenuRoot - create a new menu root
  610.  *
  611.  *  Returned Value:
  612.  *    (MenuRoot *)
  613.  *
  614.  *  Inputs:
  615.  *    name    - the name of the menu root
  616.  *
  617.  ***********************************************************************
  618.  */
  619.  
  620. MenuRoot *
  621. NewMenuRoot(name)
  622.     char *name;
  623. {
  624.     MenuRoot *tmp;
  625.  
  626. #define UNUSED_PIXEL ((unsigned long) (~0))    /* more than 24 bits */
  627.  
  628.     tmp = (MenuRoot *) malloc(sizeof(MenuRoot));
  629.     tmp->hi_fore = UNUSED_PIXEL;
  630.     tmp->hi_back = UNUSED_PIXEL;
  631.     tmp->name = name;
  632.     tmp->prev = NULL;
  633.     tmp->first = NULL;
  634.     tmp->last = NULL;
  635.     tmp->items = 0;
  636.     tmp->width = 0;
  637.     tmp->mapped = NEVER_MAPPED;
  638.     tmp->pull = FALSE;
  639.     tmp->w = None;
  640.     tmp->shadow = None;
  641.     tmp->real_menu = FALSE;
  642.  
  643.     if (Scr->MenuList == NULL)
  644.     {
  645.     Scr->MenuList = tmp;
  646.     Scr->MenuList->next = NULL;
  647.     }
  648.  
  649.     if (Scr->LastMenu == NULL)
  650.     {
  651.     Scr->LastMenu = tmp;
  652.     Scr->LastMenu->next = NULL;
  653.     }
  654.     else
  655.     {
  656.     Scr->LastMenu->next = tmp;
  657.     Scr->LastMenu = tmp;
  658.     Scr->LastMenu->next = NULL;
  659.     }
  660.  
  661.     if (strcmp(name, TWM_WINDOWS) == 0)
  662.     Scr->Windows = tmp;
  663.  
  664.     return (tmp);
  665. }
  666.  
  667.  
  668.  
  669. /***********************************************************************
  670.  *
  671.  *  Procedure:
  672.  *    AddToMenu - add an item to a root menu
  673.  *
  674.  *  Returned Value:
  675.  *    (MenuItem *)
  676.  *
  677.  *  Inputs:
  678.  *    menu    - pointer to the root menu to add the item
  679.  *    item    - the text to appear in the menu
  680.  *    action    - the string to possibly execute
  681.  *    sub    - the menu root if it is a pull-right entry
  682.  *    func    - the numeric function
  683.  *    fore    - foreground color string
  684.  *    back    - background color string
  685.  *
  686.  ***********************************************************************
  687.  */
  688.  
  689. MenuItem *
  690. AddToMenu(menu, item, action, sub, func, fore, back)
  691.     MenuRoot *menu;
  692.     char *item, *action;
  693.     MenuRoot *sub;
  694.     int func;
  695.     char *fore, *back;
  696. {
  697.     MenuItem *tmp;
  698.     int width;
  699.  
  700. #ifdef DEBUG_MENUS
  701.     fprintf(stderr, "adding menu item=\"%s\", action=%s, sub=%d, f=%d\n",
  702.     item, action, sub, func);
  703. #endif
  704.  
  705.     tmp = (MenuItem *) malloc(sizeof(MenuItem));
  706.     tmp->root = menu;
  707.  
  708.     if (menu->first == NULL)
  709.     {
  710.     menu->first = tmp;
  711.     tmp->prev = NULL;
  712.     }
  713.     else
  714.     {
  715.     menu->last->next = tmp;
  716.     tmp->prev = menu->last;
  717.     }
  718.     menu->last = tmp;
  719.  
  720.     tmp->item = item;
  721.     tmp->strlen = strlen(item);
  722.     tmp->action = action;
  723.     tmp->next = NULL;
  724.     tmp->sub = NULL;
  725.     tmp->state = 0;
  726.     tmp->func = func;
  727.  
  728.     if (!Scr->HaveFonts) CreateFonts();
  729.     width = XTextWidth(Scr->MenuFont.font, item, tmp->strlen);
  730.     if (width <= 0)
  731.     width = 1;
  732.     if (width > menu->width)
  733.     menu->width = width;
  734.  
  735.     tmp->user_colors = FALSE;
  736.     if (Scr->Monochrome == COLOR && fore != NULL)
  737.     {
  738.     int save;
  739.  
  740.     save = Scr->FirstTime;
  741.     Scr->FirstTime = TRUE;
  742.     GetColor(COLOR, &tmp->fore, fore);
  743.     GetColor(COLOR, &tmp->back, back);
  744.     Scr->FirstTime = save;
  745.     tmp->user_colors = TRUE;
  746.     }
  747.     if (sub != NULL)
  748.     {
  749.     tmp->sub = sub;
  750.     menu->pull = TRUE;
  751.     }
  752.     tmp->item_num = menu->items++;
  753.  
  754.     return (tmp);
  755. }
  756.  
  757.  
  758.  
  759. MakeMenus()
  760. {
  761.     MenuRoot *mr;
  762.  
  763.     for (mr = Scr->MenuList; mr != NULL; mr = mr->next)
  764.     {
  765.     if (mr->real_menu == FALSE)
  766.         continue;
  767.  
  768.     MakeMenu(mr);
  769.     }
  770. }
  771.  
  772.  
  773.  
  774. MakeMenu(mr)
  775. MenuRoot *mr;
  776. {
  777.     MenuItem *start, *end, *cur, *tmp;
  778.     XColor f1, f2, f3;
  779.     XColor b1, b2, b3;
  780.     XColor save_fore, save_back;
  781.     int num, i;
  782.     int fred, fgreen, fblue;
  783.     int bred, bgreen, bblue;
  784.     int width;
  785.     unsigned long valuemask;
  786.     XSetWindowAttributes attributes;
  787.     Colormap cmap = Scr->TwmRoot.cmaps.cwins[0]->colormap->c;
  788.  
  789.     Scr->EntryHeight = Scr->MenuFont.height + 4;
  790.  
  791.     /* lets first size the window accordingly */
  792.     if (mr->mapped == NEVER_MAPPED)
  793.     {
  794.     if (mr->pull == TRUE)
  795.     {
  796.         mr->width += 16 + 10;
  797.     }
  798.  
  799.     width = mr->width + 10;
  800.  
  801.     for (cur = mr->first; cur != NULL; cur = cur->next)
  802.     {
  803.         if (cur->func != F_TITLE)
  804.         cur->x = 5;
  805.         else
  806.         {
  807.         cur->x = width - XTextWidth(Scr->MenuFont.font, cur->item,
  808.             cur->strlen);
  809.         cur->x /= 2;
  810.         }
  811.     }
  812.     mr->height = mr->items * Scr->EntryHeight;
  813.     mr->width += 10;
  814.  
  815.     if (Scr->Shadow)
  816.     {
  817.         /*
  818.          * Make sure that you don't draw into the shadow window or else
  819.          * the background bits there will get saved
  820.          */
  821.         valuemask = (CWBackPixel | CWBorderPixel);
  822.         attributes.background_pixel = Scr->MenuShadowColor;
  823.         attributes.border_pixel = Scr->MenuShadowColor;
  824.         if (Scr->SaveUnder) {
  825.         valuemask |= CWSaveUnder;
  826.         attributes.save_under = True;
  827.         }
  828.         mr->shadow = XCreateWindow (dpy, Scr->Root, 0, 0,
  829.                     (unsigned int) mr->width, 
  830.                     (unsigned int) mr->height,
  831.                     (unsigned int)0,
  832.                     CopyFromParent, 
  833.                     (unsigned int) CopyFromParent,
  834.                     (Visual *) CopyFromParent,
  835.                     valuemask, &attributes);
  836.     }
  837.  
  838.     valuemask = (CWBackPixel | CWBorderPixel | CWEventMask);
  839.     attributes.background_pixel = Scr->MenuC.back;
  840.     attributes.border_pixel = Scr->MenuC.fore;
  841.     attributes.event_mask = (ExposureMask | EnterWindowMask);
  842.     if (Scr->SaveUnder) {
  843.         valuemask |= CWSaveUnder;
  844.         attributes.save_under = True;
  845.     }
  846.     if (Scr->BackingStore) {
  847.         valuemask |= CWBackingStore;
  848.         attributes.backing_store = Always;
  849.     }
  850.     mr->w = XCreateWindow (dpy, Scr->Root, 0, 0, (unsigned int) mr->width,
  851.                    (unsigned int) mr->height, (unsigned int) 1,
  852.                    CopyFromParent, (unsigned int) CopyFromParent,
  853.                    (Visual *) CopyFromParent,
  854.                    valuemask, &attributes);
  855.  
  856.  
  857.     XSaveContext(dpy, mr->w, MenuContext, (caddr_t)mr);
  858.     XSaveContext(dpy, mr->w, ScreenContext, (caddr_t)Scr);
  859.  
  860.     mr->mapped = UNMAPPED;
  861.     }
  862.  
  863.     /* get the default colors into the menus */
  864.     for (tmp = mr->first; tmp != NULL; tmp = tmp->next)
  865.     {
  866.     if (!tmp->user_colors) {
  867.         if (tmp->func != F_TITLE) {
  868.         tmp->fore = Scr->MenuC.fore;
  869.         tmp->back = Scr->MenuC.back;
  870.         } else {
  871.         tmp->fore = Scr->MenuTitleC.fore;
  872.         tmp->back = Scr->MenuTitleC.back;
  873.         }
  874.     }
  875.  
  876.     if (mr->hi_fore != UNUSED_PIXEL)
  877.     {
  878.         tmp->hi_fore = mr->hi_fore;
  879.         tmp->hi_back = mr->hi_back;
  880.     }
  881.     else
  882.     {
  883.         tmp->hi_fore = tmp->back;
  884.         tmp->hi_back = tmp->fore;
  885.     }
  886.     }
  887.  
  888.     if (Scr->Monochrome == MONOCHROME || !Scr->InterpolateMenuColors)
  889.     return;
  890.  
  891.     start = mr->first;
  892.     while (TRUE)
  893.     {
  894.     for (; start != NULL; start = start->next)
  895.     {
  896.         if (start->user_colors)
  897.         break;
  898.     }
  899.     if (start == NULL)
  900.         break;
  901.  
  902.     for (end = start->next; end != NULL; end = end->next)
  903.     {
  904.         if (end->user_colors)
  905.         break;
  906.     }
  907.     if (end == NULL)
  908.         break;
  909.  
  910.     /* we have a start and end to interpolate between */
  911.     num = end->item_num - start->item_num;
  912.  
  913.     f1.pixel = start->fore;
  914.     XQueryColor(dpy, cmap, &f1);
  915.     f2.pixel = end->fore;
  916.     XQueryColor(dpy, cmap, &f2);
  917.  
  918.     b1.pixel = start->back;
  919.     XQueryColor(dpy, cmap, &b1);
  920.     b2.pixel = end->back;
  921.     XQueryColor(dpy, cmap, &b2);
  922.  
  923.     fred = ((int)f2.red - (int)f1.red) / num;
  924.     fgreen = ((int)f2.green - (int)f1.green) / num;
  925.     fblue = ((int)f2.blue - (int)f1.blue) / num;
  926.  
  927.     bred = ((int)b2.red - (int)b1.red) / num;
  928.     bgreen = ((int)b2.green - (int)b1.green) / num;
  929.     bblue = ((int)b2.blue - (int)b1.blue) / num;
  930.  
  931.     f3 = f1;
  932.     f3.flags = DoRed | DoGreen | DoBlue;
  933.  
  934.     b3 = b1;
  935.     b3.flags = DoRed | DoGreen | DoBlue;
  936.  
  937.     num -= 1;
  938.     for (i = 0, cur = start->next; i < num; i++, cur = cur->next)
  939.     {
  940.         f3.red += fred;
  941.         f3.green += fgreen;
  942.         f3.blue += fblue;
  943.         save_fore = f3;
  944.  
  945.         b3.red += bred;
  946.         b3.green += bgreen;
  947.         b3.blue += bblue;
  948.         save_back = b3;
  949.  
  950.         XAllocColor(dpy, cmap, &f3);
  951.         XAllocColor(dpy, cmap, &b3);
  952.         cur->hi_back = cur->fore = f3.pixel;
  953.         cur->hi_fore = cur->back = b3.pixel;
  954.         cur->user_colors = True;
  955.  
  956.         f3 = save_fore;
  957.         b3 = save_back;
  958.     }
  959.     start = end;
  960.     }
  961. }
  962.  
  963.  
  964.  
  965. /***********************************************************************
  966.  *
  967.  *  Procedure:
  968.  *    PopUpMenu - pop up a pull down menu
  969.  *
  970.  *  Inputs:
  971.  *    menu    - the root pointer of the menu to pop up
  972.  *    x, y    - location of upper left of menu
  973.  *      center    - whether or not to center horizontally over position
  974.  *
  975.  ***********************************************************************
  976.  */
  977.  
  978. Bool PopUpMenu (menu, x, y, center)
  979.     MenuRoot *menu;
  980.     int x, y;
  981.     Bool center;
  982. {
  983.     int WindowNameOffset, WindowNameCount;
  984.     TwmWindow **WindowNames;
  985.     TwmWindow *tmp_win2,*tmp_win3;
  986.     int i;
  987.     int (*compar)() = 
  988.       (Scr->CaseSensitive ? strcmp : XmuCompareISOLatin1);
  989.  
  990.     if (!menu) return False;
  991.  
  992.     InstallRootColormap();
  993.  
  994.     if (menu == Scr->Windows)
  995.     {
  996.     TwmWindow *tmp_win;
  997.  
  998.     /* this is the twm windows menu,  let's go ahead and build it */
  999.  
  1000.     DestroyMenu (menu);
  1001.  
  1002.     menu->first = NULL;
  1003.     menu->last = NULL;
  1004.     menu->items = 0;
  1005.     menu->width = 0;
  1006.     menu->mapped = NEVER_MAPPED;
  1007.       AddToMenu(menu, "TWM Windows", NULLSTR, NULL, F_TITLE,NULLSTR,NULLSTR);
  1008.   
  1009.         WindowNameOffset=(char *)Scr->TwmRoot.next->name -
  1010.                                (char *)Scr->TwmRoot.next;
  1011.         for(tmp_win = Scr->TwmRoot.next , WindowNameCount=0;
  1012.             tmp_win != NULL;
  1013.             tmp_win = tmp_win->next)
  1014.           WindowNameCount++;
  1015.         WindowNames =
  1016.           (TwmWindow **)malloc(sizeof(TwmWindow *)*WindowNameCount);
  1017.         WindowNames[0] = Scr->TwmRoot.next;
  1018.         for(tmp_win = Scr->TwmRoot.next->next , WindowNameCount=1;
  1019.             tmp_win != NULL;
  1020.             tmp_win = tmp_win->next,WindowNameCount++)
  1021.         {
  1022.             tmp_win2 = tmp_win;
  1023.             for (i=0;i<WindowNameCount;i++)
  1024.             {
  1025.                 if ((*compar)(tmp_win2->name,WindowNames[i]->name) < 0)
  1026.                 {
  1027.                     tmp_win3 = tmp_win2;
  1028.                     tmp_win2 = WindowNames[i];
  1029.                     WindowNames[i] = tmp_win3;
  1030.                 }
  1031.             }
  1032.             WindowNames[WindowNameCount] = tmp_win2;
  1033.         }
  1034.         for (i=0; i<WindowNameCount; i++)
  1035.         {
  1036.             AddToMenu(menu, WindowNames[i]->name, (char *)WindowNames[i],
  1037.                       NULL, F_POPUP,NULL,NULL);
  1038.         }
  1039.         free(WindowNames);
  1040.  
  1041.     MakeMenu(menu);
  1042.     }
  1043.  
  1044.     if (menu->w == None || menu->items == 0) return False;
  1045.  
  1046.     /* Prevent recursively bringing up menus. */
  1047.     if (menu->mapped == MAPPED) return False;
  1048.  
  1049.     /*
  1050.      * Dynamically set the parent;  this allows pull-ups to also be main
  1051.      * menus, or to be brought up from more than one place.
  1052.      */
  1053.     menu->prev = ActiveMenu;
  1054.  
  1055.     XGrabPointer(dpy, Scr->Root, True,
  1056.     ButtonPressMask | ButtonReleaseMask |
  1057.     ButtonMotionMask | PointerMotionHintMask,
  1058.     GrabModeAsync, GrabModeAsync,
  1059.     Scr->Root, Scr->MenuCursor, CurrentTime);
  1060.  
  1061.     ActiveMenu = menu;
  1062.     menu->mapped = MAPPED;
  1063.     menu->entered = FALSE;
  1064.  
  1065.     if (center) {
  1066.     x -= (menu->width / 2);
  1067.     y -= (Scr->EntryHeight / 2);    /* sticky menus would be nice here */
  1068.     }
  1069.  
  1070.     /*
  1071.      * clip to screen
  1072.      */
  1073.     if (x + menu->width > Scr->MyDisplayWidth) {
  1074.     x = Scr->MyDisplayWidth - menu->width;
  1075.     }
  1076.     if (x < 0) x = 0;
  1077.     if (y + menu->height > Scr->MyDisplayHeight) {
  1078.     y = Scr->MyDisplayHeight - menu->height;
  1079.     }
  1080.     if (y < 0) y = 0;
  1081.  
  1082.     MenuOrigins[MenuDepth].x = x;
  1083.     MenuOrigins[MenuDepth].y = y;
  1084.     MenuDepth++;
  1085.  
  1086.     XMoveWindow(dpy, menu->w, x, y);
  1087.     if (Scr->Shadow) {
  1088.     XMoveWindow (dpy, menu->shadow, x + SHADOWWIDTH, y + SHADOWWIDTH);
  1089.     }
  1090.     if (Scr->Shadow) {
  1091.     XRaiseWindow (dpy, menu->shadow);
  1092.     }
  1093.     XMapRaised(dpy, menu->w);
  1094.     if (Scr->Shadow) {
  1095.     XMapWindow (dpy, menu->shadow);
  1096.     }
  1097.     XSync(dpy, 0);
  1098.     return True;
  1099. }
  1100.  
  1101.  
  1102.  
  1103. /***********************************************************************
  1104.  *
  1105.  *  Procedure:
  1106.  *    PopDownMenu - unhighlight the current menu selection and
  1107.  *        take down the menus
  1108.  *
  1109.  ***********************************************************************
  1110.  */
  1111.  
  1112. PopDownMenu()
  1113. {
  1114.     MenuRoot *tmp;
  1115.  
  1116.     if (ActiveMenu == NULL)
  1117.     return;
  1118.  
  1119.     if (ActiveItem)
  1120.     {
  1121.     ActiveItem->state = 0;
  1122.     PaintEntry(ActiveMenu, ActiveItem, False);
  1123.     }
  1124.  
  1125.     for (tmp = ActiveMenu; tmp != NULL; tmp = tmp->prev)
  1126.     {
  1127.     if (Scr->Shadow) {
  1128.         XUnmapWindow (dpy, tmp->shadow);
  1129.     }
  1130.     XUnmapWindow(dpy, tmp->w);
  1131.     tmp->mapped = UNMAPPED;
  1132.     UninstallRootColormap();
  1133.     }
  1134.  
  1135.     XFlush(dpy);
  1136.     ActiveMenu = NULL;
  1137.     ActiveItem = NULL;
  1138.     MenuDepth = 0;
  1139.     if (Context == C_WINDOW || Context == C_FRAME || Context == C_TITLE)
  1140.       menuFromFrameOrWindowOrTitlebar = TRUE;
  1141. }
  1142.  
  1143.  
  1144.  
  1145. /***********************************************************************
  1146.  *
  1147.  *  Procedure:
  1148.  *    FindMenuRoot - look for a menu root
  1149.  *
  1150.  *  Returned Value:
  1151.  *    (MenuRoot *)  - a pointer to the menu root structure 
  1152.  *
  1153.  *  Inputs:
  1154.  *    name    - the name of the menu root 
  1155.  *
  1156.  ***********************************************************************
  1157.  */
  1158.  
  1159. MenuRoot *
  1160. FindMenuRoot(name)
  1161.     char *name;
  1162. {
  1163.     MenuRoot *tmp;
  1164.  
  1165.     for (tmp = Scr->MenuList; tmp != NULL; tmp = tmp->next)
  1166.     {
  1167.     if (strcmp(name, tmp->name) == 0)
  1168.         return (tmp);
  1169.     }
  1170.     return NULL;
  1171. }
  1172.  
  1173.  
  1174.  
  1175. static Bool belongs_to_twm_window (t, w)
  1176.     register TwmWindow *t;
  1177.     register Window w;
  1178. {
  1179.     if (!t) return False;
  1180.  
  1181.     if (w == t->frame || w == t->title_w || w == t->hilite_w ||
  1182.     w == t->icon_w || w == t->icon_bm_w) return True;
  1183.     
  1184.     if (t && t->titlebuttons) {
  1185.     register TBWindow *tbw;
  1186.     register int nb = Scr->TBInfo.nleft + Scr->TBInfo.nright;
  1187.     for (tbw = t->titlebuttons; nb > 0; tbw++, nb--) {
  1188.         if (tbw->window == w) return True;
  1189.     }
  1190.     }
  1191.     return False;
  1192. }
  1193.  
  1194.  
  1195.  
  1196.  
  1197. /***********************************************************************
  1198.  *
  1199.  *  Procedure:
  1200.  *    resizeFromCenter -
  1201.  *
  1202.  ***********************************************************************
  1203.  */
  1204.  
  1205.  
  1206. extern int AddingX;
  1207. extern int AddingY;
  1208. extern int AddingW;
  1209. extern int AddingH;
  1210.  
  1211. void resizeFromCenter(w, tmp_win)
  1212.      Window w;
  1213.      TwmWindow *tmp_win;
  1214. {
  1215.   int lastx, lasty, width, height, bw2;
  1216.   int namelen;
  1217.   int stat;
  1218.   XEvent event;
  1219.   Window junk;
  1220.  
  1221.   namelen = strlen (tmp_win->name);
  1222.   bw2 = tmp_win->frame_bw * 2;
  1223.   AddingW = tmp_win->attr.width + bw2;
  1224.   AddingH = tmp_win->attr.height + tmp_win->title_height + bw2;
  1225.   width = (SIZE_HINDENT + XTextWidth (Scr->SizeFont.font,
  1226.                       tmp_win->name, namelen));
  1227.   height = Scr->SizeFont.height + SIZE_VINDENT * 2;
  1228.   XGetGeometry(dpy, w, &JunkRoot, &origDragX, &origDragY,
  1229.            (unsigned int *)&DragWidth, (unsigned int *)&DragHeight, 
  1230.            &JunkBW, &JunkDepth);
  1231.   XWarpPointer(dpy, None, w,
  1232.            0, 0, 0, 0, DragWidth/2, DragHeight/2);   
  1233.   XQueryPointer (dpy, Scr->Root, &JunkRoot, 
  1234.          &JunkChild, &JunkX, &JunkY,
  1235.          &AddingX, &AddingY, &JunkMask);
  1236. /*****
  1237.   Scr->SizeStringOffset = width +
  1238.     XTextWidth(Scr->SizeFont.font, ": ", 2);
  1239.   XResizeWindow (dpy, Scr->SizeWindow, Scr->SizeStringOffset +
  1240.          Scr->SizeStringWidth, height);
  1241.   XDrawImageString (dpy, Scr->SizeWindow, Scr->NormalGC, width,
  1242.             SIZE_VINDENT + Scr->SizeFont.font->ascent,
  1243.             ": ", 2);
  1244. *****/
  1245.   lastx = -10000;
  1246.   lasty = -10000;
  1247. /*****
  1248.   MoveOutline(Scr->Root,
  1249.           origDragX - JunkBW, origDragY - JunkBW,
  1250.           DragWidth * JunkBW, DragHeight * JunkBW,
  1251.           tmp_win->frame_bw,
  1252.           tmp_win->title_height);
  1253. *****/
  1254.   MenuStartResize(tmp_win, origDragX, origDragY, DragWidth, DragHeight);
  1255.   while (TRUE)
  1256.     {
  1257.       XMaskEvent(dpy,
  1258.          ButtonPressMask | PointerMotionMask, &event);
  1259.       
  1260.       if (event.type == MotionNotify) {
  1261.     /* discard any extra motion events before a release */
  1262.     while(XCheckMaskEvent(dpy,
  1263.                   ButtonMotionMask | ButtonPressMask, &event))
  1264.       if (event.type == ButtonPress)
  1265.         break;
  1266.       }
  1267.       
  1268.       if (event.type == ButtonPress)
  1269.     {
  1270.       MenuEndResize(tmp_win);
  1271.       XMoveResizeWindow(dpy, w, AddingX, AddingY, AddingW, AddingH);
  1272.       break;
  1273.     }
  1274.       
  1275. /*    if (!DispatchEvent ()) continue; */
  1276.  
  1277.       if (event.type != MotionNotify) {
  1278.     continue;
  1279.       }
  1280.       
  1281.       /*
  1282.        * XXX - if we are going to do a loop, we ought to consider
  1283.        * using multiple GXxor lines so that we don't need to 
  1284.        * grab the server.
  1285.        */
  1286.       XQueryPointer(dpy, Scr->Root, &JunkRoot, &JunkChild,
  1287.             &JunkX, &JunkY, &AddingX, &AddingY, &JunkMask);
  1288.       
  1289.       if (lastx != AddingX || lasty != AddingY)
  1290.     {
  1291.       MenuDoResize(AddingX, AddingY, tmp_win);
  1292.       
  1293.       lastx = AddingX;
  1294.       lasty = AddingY;
  1295.     }
  1296.       
  1297.     }
  1298. } 
  1299.  
  1300.  
  1301.  
  1302. /***********************************************************************
  1303.  *
  1304.  *  Procedure:
  1305.  *    ExecuteFunction - execute a twm root function
  1306.  *
  1307.  *  Inputs:
  1308.  *    func    - the function to execute
  1309.  *    action    - the menu action to execute 
  1310.  *    w    - the window to execute this function on
  1311.  *    tmp_win    - the twm window structure
  1312.  *    event    - the event that caused the function
  1313.  *    context - the context in which the button was pressed
  1314.  *    pulldown- flag indicating execution from pull down menu
  1315.  *
  1316.  *  Returns:
  1317.  *    TRUE if should continue with remaining actions else FALSE to abort
  1318.  *
  1319.  ***********************************************************************
  1320.  */
  1321.  
  1322. int
  1323. ExecuteFunction(func, action, w, tmp_win, eventp, context, pulldown)
  1324.     int func;
  1325.     char *action;
  1326.     Window w;
  1327.     TwmWindow *tmp_win;
  1328.     XEvent *eventp;
  1329.     int context;
  1330.     int pulldown;
  1331. {
  1332.     static Time last_time = 0;
  1333.     char tmp[200];
  1334.     char *ptr;
  1335.     char buff[MAX_FILE_SIZE];
  1336.     int count, fd;
  1337.     Window rootw;
  1338.     int origX, origY;
  1339.     int do_next_action = TRUE;
  1340.     int moving_icon = FALSE;
  1341.     Bool fromtitlebar = False;
  1342.     extern int ConstrainedMoveTime;
  1343.  
  1344.     RootFunction = NULL;
  1345.     if (Cancel)
  1346.     return TRUE;            /* XXX should this be FALSE? */
  1347.  
  1348.     switch (func)
  1349.     {
  1350.     case F_UPICONMGR:
  1351.     case F_LEFTICONMGR:
  1352.     case F_RIGHTICONMGR:
  1353.     case F_DOWNICONMGR:
  1354.     case F_FORWICONMGR:
  1355.     case F_BACKICONMGR:
  1356.     case F_NEXTICONMGR:
  1357.     case F_PREVICONMGR:
  1358.     case F_NOP:
  1359.     case F_TITLE:
  1360.     case F_DELTASTOP:
  1361.     case F_RAISELOWER:
  1362.     case F_WARPTOSCREEN:
  1363.     case F_WARPTO:
  1364.     case F_WARPRING:
  1365.     case F_WARPTOICONMGR:
  1366.     case F_COLORMAP:
  1367.     break;
  1368.     default:
  1369.         XGrabPointer(dpy, Scr->Root, True,
  1370.             ButtonPressMask | ButtonReleaseMask,
  1371.             GrabModeAsync, GrabModeAsync,
  1372.             Scr->Root, Scr->WaitCursor, CurrentTime);
  1373.     break;
  1374.     }
  1375.  
  1376.     switch (func)
  1377.     {
  1378.     case F_NOP:
  1379.     case F_TITLE:
  1380.     break;
  1381.  
  1382.     case F_DELTASTOP:
  1383.     if (WindowMoved) do_next_action = FALSE;
  1384.     break;
  1385.  
  1386.     case F_RESTART:
  1387.     XSync (dpy, 0);
  1388.     Reborder (eventp->xbutton.time);
  1389.     XSync (dpy, 0);
  1390.     execvp(*Argv, Argv);
  1391.     fprintf (stderr, "%s:  unable to restart:  %s\n", ProgramName, *Argv);
  1392.     break;
  1393.  
  1394.     case F_UPICONMGR:
  1395.     case F_DOWNICONMGR:
  1396.     case F_LEFTICONMGR:
  1397.     case F_RIGHTICONMGR:
  1398.     case F_FORWICONMGR:
  1399.     case F_BACKICONMGR:
  1400.     MoveIconManager(func);
  1401.         break;
  1402.  
  1403.     case F_NEXTICONMGR:
  1404.     case F_PREVICONMGR:
  1405.     JumpIconManager(func);
  1406.         break;
  1407.  
  1408.     case F_SHOWLIST:
  1409.     if (Scr->NoIconManagers)
  1410.         break;
  1411.     DeIconify(Scr->iconmgr.twm_win);
  1412.     XRaiseWindow(dpy, Scr->iconmgr.twm_win->frame);
  1413.     break;
  1414.  
  1415.     case F_HIDELIST:
  1416.     if (Scr->NoIconManagers)
  1417.         break;
  1418.     HideIconManager ();
  1419.     break;
  1420.  
  1421.     case F_SORTICONMGR:
  1422.     if (DeferExecution(context, func, Scr->SelectCursor))
  1423.         return TRUE;
  1424.  
  1425.     {
  1426.         int save_sort;
  1427.  
  1428.         save_sort = Scr->SortIconMgr;
  1429.         Scr->SortIconMgr = TRUE;
  1430.  
  1431.         if (context == C_ICONMGR)
  1432.         SortIconManager((IconMgr *) NULL);
  1433.         else if (tmp_win->iconmgr)
  1434.         SortIconManager(tmp_win->iconmgrp);
  1435.         else
  1436.         XBell(dpy, 0);
  1437.  
  1438.         Scr->SortIconMgr = save_sort;
  1439.     }
  1440.     break;
  1441.  
  1442.     case F_IDENTIFY:
  1443.     if (DeferExecution(context, func, Scr->SelectCursor))
  1444.         return TRUE;
  1445.  
  1446.     Identify(tmp_win);
  1447.     break;
  1448.  
  1449.     case F_VERSION:
  1450.     Identify ((TwmWindow *) NULL);
  1451.     break;
  1452.  
  1453.     case F_AUTORAISE:
  1454.     if (DeferExecution(context, func, Scr->SelectCursor))
  1455.         return TRUE;
  1456.  
  1457.     tmp_win->auto_raise = !tmp_win->auto_raise;
  1458.     if (tmp_win->auto_raise) ++(Scr->NumAutoRaises);
  1459.     else --(Scr->NumAutoRaises);
  1460.     break;
  1461.  
  1462.     case F_BEEP:
  1463.     XBell(dpy, 0);
  1464.     break;
  1465.  
  1466.     case F_POPUP:
  1467.     tmp_win = (TwmWindow *)action;
  1468.     if (Scr->WindowFunction.func != NULL)
  1469.     {
  1470.        ExecuteFunction(Scr->WindowFunction.func,
  1471.                Scr->WindowFunction.item->action,
  1472.                w, tmp_win, eventp, C_FRAME, FALSE);
  1473.     }
  1474.     else
  1475.     {
  1476.         DeIconify(tmp_win);
  1477.         XRaiseWindow (dpy, tmp_win->frame);
  1478.     }
  1479.     break;
  1480.  
  1481.     case F_RESIZE:
  1482.     EventHandler[EnterNotify] = HandleUnknown;
  1483.     EventHandler[LeaveNotify] = HandleUnknown;
  1484.     if (DeferExecution(context, func, Scr->MoveCursor))
  1485.         return TRUE;
  1486.  
  1487.     PopDownMenu();
  1488.  
  1489.     if (pulldown)
  1490.         XWarpPointer(dpy, None, Scr->Root, 
  1491.         0, 0, 0, 0, eventp->xbutton.x_root, eventp->xbutton.y_root);
  1492.  
  1493.     if (w != tmp_win->icon_w) {    /* can't resize icons */
  1494.  
  1495.       if ((Context == C_FRAME || Context == C_WINDOW || Context == C_TITLE)
  1496.           && fromMenu) 
  1497.         resizeFromCenter(w, tmp_win);
  1498.       else {
  1499.         /*
  1500.          * see if this is being done from the titlebar
  1501.          */
  1502.         fromtitlebar = 
  1503.           belongs_to_twm_window (tmp_win, eventp->xbutton.window);
  1504.         
  1505.         /* Save pointer position so we can tell if it was moved or
  1506.            not during the resize. */
  1507.         ResizeOrigX = eventp->xbutton.x_root;
  1508.         ResizeOrigY = eventp->xbutton.y_root;
  1509.         
  1510.         StartResize (eventp, tmp_win, fromtitlebar);
  1511.         
  1512.         do {
  1513.           XMaskEvent(dpy,
  1514.                ButtonPressMask | ButtonReleaseMask |
  1515.                EnterWindowMask | LeaveWindowMask |
  1516.                ButtonMotionMask, &Event);
  1517.         
  1518.         if (fromtitlebar && Event.type == ButtonPress) {
  1519.           fromtitlebar = False;
  1520.             continue;
  1521.           }
  1522.         
  1523.             if (Event.type == MotionNotify) {
  1524.           /* discard any extra motion events before a release */
  1525.           while
  1526.             (XCheckMaskEvent
  1527.              (dpy, ButtonMotionMask | ButtonReleaseMask, &Event))
  1528.               if (Event.type == ButtonRelease)
  1529.             break;
  1530.         }
  1531.           
  1532.           if (!DispatchEvent ()) continue;
  1533.           
  1534.         } while (!(Event.type == ButtonRelease || Cancel));
  1535.         return TRUE;
  1536.       }
  1537.     } 
  1538.     break;
  1539.  
  1540.  
  1541.     case F_ZOOM:
  1542.     case F_HORIZOOM:
  1543.     case F_FULLZOOM:
  1544.     case F_LEFTZOOM:
  1545.     case F_RIGHTZOOM:
  1546.     case F_TOPZOOM:
  1547.     case F_BOTTOMZOOM:
  1548.     if (DeferExecution(context, func, Scr->SelectCursor))
  1549.         return TRUE;
  1550.     fullzoom(tmp_win, func);
  1551.     break;
  1552.  
  1553.     case F_MOVE:
  1554.     case F_FORCEMOVE:
  1555.     if (DeferExecution(context, func, Scr->MoveCursor))
  1556.         return TRUE;
  1557.  
  1558.     PopDownMenu();
  1559.     rootw = eventp->xbutton.root;
  1560.     MoveFunction = func;
  1561.  
  1562.     if (pulldown)
  1563.         XWarpPointer(dpy, None, Scr->Root, 
  1564.         0, 0, 0, 0, eventp->xbutton.x_root, eventp->xbutton.y_root);
  1565.  
  1566.     EventHandler[EnterNotify] = HandleUnknown;
  1567.     EventHandler[LeaveNotify] = HandleUnknown;
  1568.  
  1569.     if (!Scr->NoGrabServer || !Scr->OpaqueMove) {
  1570.         XGrabServer(dpy);
  1571.     }
  1572.     XGrabPointer(dpy, eventp->xbutton.root, True,
  1573.         ButtonPressMask | ButtonReleaseMask |
  1574.         ButtonMotionMask | PointerMotionMask, /* PointerMotionHintMask */
  1575.         GrabModeAsync, GrabModeAsync,
  1576.         Scr->Root, Scr->MoveCursor, CurrentTime);
  1577.  
  1578.     if (context == C_ICON && tmp_win->icon_w)
  1579.     {
  1580.         w = tmp_win->icon_w;
  1581.         DragX = eventp->xbutton.x;
  1582.         DragY = eventp->xbutton.y;
  1583.         moving_icon = TRUE;
  1584.     }
  1585.  
  1586.     else if (w != tmp_win->icon_w)
  1587.     {
  1588.         XTranslateCoordinates(dpy, w, tmp_win->frame,
  1589.         eventp->xbutton.x, 
  1590.         eventp->xbutton.y, 
  1591.         &DragX, &DragY, &JunkChild);
  1592.  
  1593.         w = tmp_win->frame;
  1594.     }
  1595.  
  1596.     DragWindow = None;
  1597.  
  1598.     XGetGeometry(dpy, w, &JunkRoot, &origDragX, &origDragY,
  1599.         (unsigned int *)&DragWidth, (unsigned int *)&DragHeight, &JunkBW,
  1600.         &JunkDepth);
  1601.  
  1602.     origX = eventp->xbutton.x_root;
  1603.     origY = eventp->xbutton.y_root;
  1604.     CurrentDragX = origDragX;
  1605.     CurrentDragY = origDragY;
  1606.  
  1607.     /*
  1608.      * only do the constrained move if timer is set; need to check it
  1609.      * in case of stupid or wicked fast servers
  1610.      */
  1611.     if (ConstrainedMoveTime && 
  1612.         (eventp->xbutton.time - last_time) < ConstrainedMoveTime)
  1613.     {
  1614.         int width, height;
  1615.  
  1616.         ConstMove = TRUE;
  1617.         ConstMoveDir = MOVE_NONE;
  1618.         ConstMoveX = eventp->xbutton.x_root - DragX - JunkBW;
  1619.         ConstMoveY = eventp->xbutton.y_root - DragY - JunkBW;
  1620.         width = DragWidth + 2 * JunkBW;
  1621.         height = DragHeight + 2 * JunkBW;
  1622.         ConstMoveXL = ConstMoveX + width/3;
  1623.         ConstMoveXR = ConstMoveX + 2*(width/3);
  1624.         ConstMoveYT = ConstMoveY + height/3;
  1625.         ConstMoveYB = ConstMoveY + 2*(height/3);
  1626.  
  1627.         XWarpPointer(dpy, None, w,
  1628.         0, 0, 0, 0, DragWidth/2, DragHeight/2);
  1629.  
  1630.         XQueryPointer(dpy, w, &JunkRoot, &JunkChild,
  1631.         &JunkX, &JunkY, &DragX, &DragY, &JunkMask);
  1632.     }
  1633.     last_time = eventp->xbutton.time;
  1634.  
  1635.     if (!Scr->OpaqueMove)
  1636.     {
  1637.         InstallRootColormap();
  1638.         if (!Scr->MoveDelta)
  1639.         {
  1640.         /*
  1641.          * Draw initial outline.  This was previously done the
  1642.          * first time though the outer loop by dropping out of
  1643.          * the XCheckMaskEvent inner loop down to one of the
  1644.          * MoveOutline's below.
  1645.          */
  1646.         MoveOutline(rootw,
  1647.             origDragX - JunkBW, origDragY - JunkBW,
  1648.             DragWidth + 2 * JunkBW, DragHeight + 2 * JunkBW,
  1649.             tmp_win->frame_bw,
  1650.             moving_icon ? 0 : tmp_win->title_height);
  1651.         /*
  1652.          * This next line causes HandleReleaseNotify to call
  1653.          * XRaiseWindow().  This is solely to preserve the
  1654.          * previous behaviour that raises a window being moved
  1655.          * on button release even if you never actually moved
  1656.          * any distance (unless you move less than MoveDelta or
  1657.          * NoRaiseMove is set or OpaqueMove is set).
  1658.          */
  1659.         DragWindow = w;
  1660.         }
  1661.     }
  1662.  
  1663.     /*
  1664.      * see if this is being done from the titlebar
  1665.      */
  1666.     fromtitlebar = belongs_to_twm_window (tmp_win, eventp->xbutton.window);
  1667.  
  1668.     if (menuFromFrameOrWindowOrTitlebar) {
  1669.       /* warp the pointer to the middle of the window */
  1670.       XWarpPointer(dpy, None, Scr->Root, 0, 0, 0, 0, 
  1671.                origDragX + DragWidth / 2, 
  1672.                origDragY + DragHeight / 2);
  1673.       XFlush(dpy);
  1674.     }
  1675.     
  1676.     while (TRUE)
  1677.     {
  1678.         long releaseEvent = menuFromFrameOrWindowOrTitlebar ? 
  1679.                               ButtonPress : ButtonRelease;
  1680.         long movementMask = menuFromFrameOrWindowOrTitlebar ?
  1681.                               PointerMotionMask : ButtonMotionMask;
  1682.  
  1683.         /* block until there is an interesting event */
  1684.         XMaskEvent(dpy, ButtonPressMask | ButtonReleaseMask |
  1685.                     EnterWindowMask | LeaveWindowMask |
  1686.                     ExposureMask | movementMask |
  1687.                     VisibilityChangeMask, &Event);
  1688.  
  1689.         /* throw away enter and leave events until release */
  1690.         if (Event.xany.type == EnterNotify ||
  1691.         Event.xany.type == LeaveNotify) continue; 
  1692.  
  1693.         if (Event.type == MotionNotify) {
  1694.         /* discard any extra motion events before a logical release */
  1695.         while(XCheckMaskEvent(dpy,
  1696.             movementMask | releaseEvent, &Event))
  1697.             if (Event.type == releaseEvent)
  1698.             break;
  1699.         }
  1700.  
  1701.         /* test to see if we have a second button press to abort move */
  1702.         if (!menuFromFrameOrWindowOrTitlebar)
  1703.           if (Event.type == ButtonPress && DragWindow != None) {
  1704.         if (Scr->OpaqueMove)
  1705.           XMoveWindow (dpy, DragWindow, origDragX, origDragY);
  1706.         else
  1707.           MoveOutline(Scr->Root, 0, 0, 0, 0, 0, 0);
  1708.         DragWindow = None;
  1709.           }
  1710.  
  1711.         if (fromtitlebar && Event.type == ButtonPress) {
  1712.         fromtitlebar = False;
  1713.         CurrentDragX = origX = Event.xbutton.x_root;
  1714.         CurrentDragY = origY = Event.xbutton.y_root;
  1715.         XTranslateCoordinates (dpy, rootw, tmp_win->frame,
  1716.                        origX, origY,
  1717.                        &DragX, &DragY, &JunkChild);
  1718.         continue;
  1719.         }
  1720.  
  1721.         if (!DispatchEvent2 ()) continue;
  1722.  
  1723.         if (Cancel)
  1724.         {
  1725.         WindowMoved = FALSE;
  1726.         if (!Scr->OpaqueMove)
  1727.             UninstallRootColormap();
  1728.             return TRUE;    /* XXX should this be FALSE? */
  1729.         }
  1730.         if (Event.type == releaseEvent)
  1731.         {
  1732.         MoveOutline(rootw, 0, 0, 0, 0, 0, 0);
  1733.         if (moving_icon &&
  1734.             ((CurrentDragX != origDragX ||
  1735.               CurrentDragY != origDragY)))
  1736.           tmp_win->icon_moved = TRUE;
  1737.         if (!Scr->OpaqueMove && menuFromFrameOrWindowOrTitlebar)
  1738.           XMoveWindow(dpy, DragWindow, 
  1739.                   Event.xbutton.x_root - DragWidth / 2,
  1740.                   Event.xbutton.y_root - DragHeight / 2);
  1741.         break;
  1742.         }
  1743.  
  1744.         /* something left to do only if the pointer moved */
  1745.         if (Event.type != MotionNotify)
  1746.         continue;
  1747.  
  1748.         XQueryPointer(dpy, rootw, &(eventp->xmotion.root), &JunkChild,
  1749.         &(eventp->xmotion.x_root), &(eventp->xmotion.y_root),
  1750.         &JunkX, &JunkY, &JunkMask);
  1751.  
  1752.         if (DragWindow == None &&
  1753.         abs(eventp->xmotion.x_root - origX) < Scr->MoveDelta &&
  1754.             abs(eventp->xmotion.y_root - origY) < Scr->MoveDelta)
  1755.         continue;
  1756.  
  1757.         WindowMoved = TRUE;
  1758.         DragWindow = w;
  1759.  
  1760.         if (!Scr->NoRaiseMove && Scr->OpaqueMove)    /* can't restore... */
  1761.           XRaiseWindow(dpy, DragWindow);
  1762.  
  1763.         if (ConstMove)
  1764.         {
  1765.         switch (ConstMoveDir)
  1766.         {
  1767.             case MOVE_NONE:
  1768.             if (eventp->xmotion.x_root < ConstMoveXL ||
  1769.                 eventp->xmotion.x_root > ConstMoveXR)
  1770.                 ConstMoveDir = MOVE_HORIZ;
  1771.  
  1772.             if (eventp->xmotion.y_root < ConstMoveYT ||
  1773.                 eventp->xmotion.y_root > ConstMoveYB)
  1774.                 ConstMoveDir = MOVE_VERT;
  1775.  
  1776.             XQueryPointer(dpy, DragWindow, &JunkRoot, &JunkChild,
  1777.                 &JunkX, &JunkY, &DragX, &DragY, &JunkMask);
  1778.             break;
  1779.  
  1780.             case MOVE_VERT:
  1781.             ConstMoveY = eventp->xmotion.y_root - DragY - JunkBW;
  1782.             break;
  1783.  
  1784.             case MOVE_HORIZ:
  1785.             ConstMoveX= eventp->xmotion.x_root - DragX - JunkBW;
  1786.             break;
  1787.         }
  1788.  
  1789.         if (ConstMoveDir != MOVE_NONE)
  1790.         {
  1791.             int xl, yt, xr, yb, w, h;
  1792.  
  1793.             xl = ConstMoveX;
  1794.             yt = ConstMoveY;
  1795.             w = DragWidth + 2 * JunkBW;
  1796.             h = DragHeight + 2 * JunkBW;
  1797.  
  1798.             if (Scr->DontMoveOff && MoveFunction != F_FORCEMOVE)
  1799.             {
  1800.             xr = xl + w;
  1801.             yb = yt + h;
  1802.  
  1803.             if (xl < 0)
  1804.                 xl = 0;
  1805.             if (xr > Scr->MyDisplayWidth)
  1806.                 xl = Scr->MyDisplayWidth - w;
  1807.  
  1808.             if (yt < 0)
  1809.                 yt = 0;
  1810.             if (yb > Scr->MyDisplayHeight)
  1811.                 yt = Scr->MyDisplayHeight - h;
  1812.             }
  1813.             CurrentDragX = xl;
  1814.             CurrentDragY = yt;
  1815.             if (Scr->OpaqueMove)
  1816.             XMoveWindow(dpy, DragWindow, xl, yt);
  1817.             else
  1818.             MoveOutline(eventp->xmotion.root, xl, yt, w, h,
  1819.                 tmp_win->frame_bw, 
  1820.                 moving_icon ? 0 : tmp_win->title_height);
  1821.         }
  1822.         }
  1823.         else if (DragWindow != None)
  1824.         {
  1825.         int xl, yt, xr, yb, w, h;
  1826.         if (!menuFromFrameOrWindowOrTitlebar) {
  1827.           xl = eventp->xmotion.x_root - DragX - JunkBW;
  1828.           yt = eventp->xmotion.y_root - DragY - JunkBW;
  1829.         }
  1830.         else {
  1831.           xl = eventp->xmotion.x_root - (DragWidth / 2);
  1832.           yt = eventp->xmotion.y_root - (DragHeight / 2);
  1833.         }          
  1834.         w = DragWidth + 2 * JunkBW;
  1835.         h = DragHeight + 2 * JunkBW;
  1836.  
  1837.         if (Scr->DontMoveOff && MoveFunction != F_FORCEMOVE)
  1838.         {
  1839.             xr = xl + w;
  1840.             yb = yt + h;
  1841.  
  1842.             if (xl < 0)
  1843.             xl = 0;
  1844.             if (xr > Scr->MyDisplayWidth)
  1845.             xl = Scr->MyDisplayWidth - w;
  1846.  
  1847.             if (yt < 0)
  1848.             yt = 0;
  1849.             if (yb > Scr->MyDisplayHeight)
  1850.             yt = Scr->MyDisplayHeight - h;
  1851.         }
  1852.  
  1853.         CurrentDragX = xl;
  1854.         CurrentDragY = yt;
  1855.         if (Scr->OpaqueMove)
  1856.             XMoveWindow(dpy, DragWindow, xl, yt);
  1857.         else
  1858.             MoveOutline(eventp->xmotion.root, xl, yt, w, h,
  1859.             tmp_win->frame_bw,
  1860.             moving_icon ? 0 : tmp_win->title_height);
  1861.         }
  1862.  
  1863.     }
  1864.  
  1865.     if (!Scr->OpaqueMove && DragWindow == None)
  1866.         UninstallRootColormap();
  1867.  
  1868.         break;
  1869.  
  1870.     case F_FUNCTION:
  1871.     {
  1872.         MenuRoot *mroot;
  1873.         MenuItem *mitem;
  1874.  
  1875.         if ((mroot = FindMenuRoot(action)) == NULL)
  1876.         {
  1877.         fprintf (stderr, "%s: couldn't find function \"%s\"\n", 
  1878.              ProgramName, action);
  1879.         return TRUE;
  1880.         }
  1881.  
  1882.         if (NeedToDefer(mroot) && DeferExecution(context, func, Scr->SelectCursor))
  1883.         return TRUE;
  1884.         else
  1885.         {
  1886.         for (mitem = mroot->first; mitem != NULL; mitem = mitem->next)
  1887.         {
  1888.             if (!ExecuteFunction (mitem->func, mitem->action, w,
  1889.                       tmp_win, eventp, context, pulldown))
  1890.               break;
  1891.         }
  1892.         }
  1893.     }
  1894.     break;
  1895.  
  1896.     case F_DEICONIFY:
  1897.     case F_ICONIFY:
  1898.     if (DeferExecution(context, func, Scr->SelectCursor))
  1899.         return TRUE;
  1900.  
  1901.     if (tmp_win->icon)
  1902.     {
  1903.         DeIconify(tmp_win);
  1904.     }
  1905.         else if (func == F_ICONIFY)
  1906.     {
  1907.         Iconify (tmp_win, eventp->xbutton.x_root - 5,
  1908.              eventp->xbutton.y_root - 5);
  1909.     }
  1910.     break;
  1911.  
  1912.     case F_RAISELOWER:
  1913.     if (DeferExecution(context, func, Scr->SelectCursor))
  1914.         return TRUE;
  1915.  
  1916.     if (!WindowMoved) {
  1917.         XWindowChanges xwc;
  1918.  
  1919.         xwc.stack_mode = Opposite;
  1920.         if (w != tmp_win->icon_w)
  1921.           w = tmp_win->frame;
  1922.         XConfigureWindow (dpy, w, CWStackMode, &xwc);
  1923.     }
  1924.     break;
  1925.     
  1926.     case F_RAISE:
  1927.     if (DeferExecution(context, func, Scr->SelectCursor))
  1928.         return TRUE;
  1929.  
  1930.     /* check to make sure raise is not from the WindowFunction */
  1931.     if (w == tmp_win->icon_w && Context != C_ROOT) 
  1932.         XRaiseWindow(dpy, tmp_win->icon_w);
  1933.     else
  1934.         XRaiseWindow(dpy, tmp_win->frame);
  1935.  
  1936.     break;
  1937.  
  1938.     case F_LOWER:
  1939.     if (DeferExecution(context, func, Scr->SelectCursor))
  1940.         return TRUE;
  1941.  
  1942.     if (w == tmp_win->icon_w)
  1943.         XLowerWindow(dpy, tmp_win->icon_w);
  1944.     else
  1945.         XLowerWindow(dpy, tmp_win->frame);
  1946.  
  1947.     break;
  1948.  
  1949.     case F_FOCUS:
  1950.     if (DeferExecution(context, func, Scr->SelectCursor))
  1951.         return TRUE;
  1952.  
  1953.     if (tmp_win->icon == FALSE)
  1954.     {
  1955.         if (!Scr->FocusRoot && Scr->Focus == tmp_win)
  1956.         {
  1957.         FocusOnRoot();
  1958.         }
  1959.         else
  1960.         {
  1961.         if (Scr->Focus != NULL) {
  1962.             SetBorder (Scr->Focus, False);
  1963.             if (Scr->Focus->hilite_w)
  1964.               XUnmapWindow (dpy, Scr->Focus->hilite_w);
  1965.         }
  1966.  
  1967.         InstallWindowColormaps (0, tmp_win);
  1968.         if (tmp_win->hilite_w) XMapWindow (dpy, tmp_win->hilite_w);
  1969.         SetBorder (tmp_win, True);
  1970.         SetFocus (tmp_win, eventp->xbutton.time);
  1971.         Scr->FocusRoot = FALSE;
  1972.         Scr->Focus = tmp_win;
  1973.         }
  1974.     }
  1975.     break;
  1976.  
  1977.     case F_DESTROY:
  1978.     if (DeferExecution(context, func, Scr->DestroyCursor))
  1979.         return TRUE;
  1980.  
  1981.     if (tmp_win->iconmgr)
  1982.         XBell(dpy, 0);
  1983.     else
  1984.         XKillClient(dpy, tmp_win->w);
  1985.     break;
  1986.  
  1987.     case F_DELETE:
  1988.     if (DeferExecution(context, func, Scr->DestroyCursor))
  1989.         return TRUE;
  1990.  
  1991.     if (tmp_win->iconmgr)        /* don't send ourself a message */
  1992.       HideIconManager ();
  1993.     else if (tmp_win->protocols & DoesWmDeleteWindow)
  1994.       SendDeleteWindowMessage (tmp_win, LastTimestamp());
  1995.     else
  1996.       XBell (dpy, 0);
  1997.     break;
  1998.  
  1999.     case F_SAVEYOURSELF:
  2000.     if (DeferExecution (context, func, Scr->SelectCursor))
  2001.       return TRUE;
  2002.  
  2003.     if (tmp_win->protocols & DoesWmSaveYourself)
  2004.       SendSaveYourselfMessage (tmp_win, LastTimestamp());
  2005.     else
  2006.       XBell (dpy, 0);
  2007.     break;
  2008.  
  2009.     case F_CIRCLEUP:
  2010.     XCirculateSubwindowsUp(dpy, Scr->Root);
  2011.     break;
  2012.  
  2013.     case F_CIRCLEDOWN:
  2014.     XCirculateSubwindowsDown(dpy, Scr->Root);
  2015.     break;
  2016.  
  2017.     case F_EXEC:
  2018.     PopDownMenu();
  2019.     if (!Scr->NoGrabServer) {
  2020.         XUngrabServer (dpy);
  2021.         XSync (dpy, 0);
  2022.     }
  2023.     Execute(action);
  2024.     break;
  2025.  
  2026.     case F_UNFOCUS:
  2027.     FocusOnRoot();
  2028.     break;
  2029.  
  2030.     case F_CUT:
  2031.     strcpy(tmp, action);
  2032.     strcat(tmp, "\n");
  2033.     XStoreBytes(dpy, tmp, strlen(tmp));
  2034.     break;
  2035.  
  2036.     case F_CUTFILE:
  2037.     ptr = XFetchBytes(dpy, &count);
  2038.     if (ptr) {
  2039.         if (sscanf (ptr, "%s", tmp) == 1) {
  2040.         XFree (ptr);
  2041.         ptr = ExpandFilename(tmp);
  2042.         if (ptr) {
  2043.             fd = open (ptr, 0);
  2044.             if (fd >= 0) {
  2045.             count = read (fd, buff, MAX_FILE_SIZE - 1);
  2046.             if (count > 0) XStoreBytes (dpy, buff, count);
  2047.             close(fd);
  2048.             } else {
  2049.             fprintf (stderr, 
  2050.                  "%s:  unable to open cut file \"%s\"\n", 
  2051.                  ProgramName, tmp);
  2052.             }
  2053.             if (ptr != tmp) free (ptr);
  2054.         } 
  2055.         } else {
  2056.         XFree(ptr);
  2057.         }
  2058.     } else {
  2059.         fprintf(stderr, "%s:  cut buffer is empty\n", ProgramName);
  2060.     }
  2061.     break;
  2062.  
  2063.     case F_WARPTOSCREEN:
  2064.     {
  2065.         if (strcmp (action, WARPSCREEN_NEXT) == 0) {
  2066.         WarpToScreen (Scr->screen + 1, 1);
  2067.         } else if (strcmp (action, WARPSCREEN_PREV) == 0) {
  2068.         WarpToScreen (Scr->screen - 1, -1);
  2069.         } else if (strcmp (action, WARPSCREEN_BACK) == 0) {
  2070.         WarpToScreen (PreviousScreen, 0);
  2071.         } else {
  2072.         WarpToScreen (atoi (action), 0);
  2073.         }
  2074.     }
  2075.     break;
  2076.  
  2077.     case F_COLORMAP:
  2078.     {
  2079.         if (strcmp (action, COLORMAP_NEXT) == 0) {
  2080.         BumpWindowColormap (tmp_win, 1);
  2081.         } else if (strcmp (action, COLORMAP_PREV) == 0) {
  2082.         BumpWindowColormap (tmp_win, -1);
  2083.         } else {
  2084.         BumpWindowColormap (tmp_win, 0);
  2085.         }
  2086.     }
  2087.     break;
  2088.  
  2089.     case F_WARPTO:
  2090.     {
  2091.         register TwmWindow *t;
  2092.         int len;
  2093.  
  2094.         len = strlen(action);
  2095.  
  2096.         for (t = Scr->TwmRoot.next; t != NULL; t = t->next) {
  2097.         if (!strncmp(action, t->class.res_name, len)) break;
  2098.         }
  2099.         if (!t) {
  2100.         for (t = Scr->TwmRoot.next; t != NULL; t = t->next) {
  2101.             if (!strncmp(action, t->class.res_name, len)) break;
  2102.         }
  2103.         if (!t) {
  2104.             for (t = Scr->TwmRoot.next; t != NULL; t = t->next) {
  2105.             if (!strncmp(action, t->class.res_class, len)) break;
  2106.             }
  2107.         }
  2108.         }
  2109.  
  2110.         if (t) {
  2111.         if (Scr->WarpUnmapped || t->mapped) {
  2112.             if (!t->mapped) DeIconify (t);
  2113.             if (!Scr->NoRaiseWarp) XRaiseWindow (dpy, t->frame);
  2114.             WarpToWindow (t);
  2115.         }
  2116.         } else {
  2117.         XBell (dpy, 0);
  2118.         }
  2119.     }
  2120.     break;
  2121.  
  2122.     case F_WARPTOICONMGR:
  2123.     {
  2124.         TwmWindow *t;
  2125.         int len;
  2126.         Window raisewin = None, iconwin = None;
  2127.  
  2128.         len = strlen(action);
  2129.         if (len == 0) {
  2130.         if (tmp_win && tmp_win->list) {
  2131.             raisewin = tmp_win->list->iconmgr->twm_win->frame;
  2132.             iconwin = tmp_win->list->icon;
  2133.         } else if (Scr->iconmgr.active) {
  2134.             raisewin = Scr->iconmgr.twm_win->frame;
  2135.             iconwin = Scr->iconmgr.active->w;
  2136.         }
  2137.         } else {
  2138.         for (t = Scr->TwmRoot.next; t != NULL; t = t->next) {
  2139.             if (strncmp (action, t->icon_name, len) == 0) {
  2140.             if (t->list && t->list->iconmgr->twm_win->mapped) {
  2141.                 raisewin = t->list->iconmgr->twm_win->frame;
  2142.                 iconwin = t->list->icon;
  2143.                 break;
  2144.             }
  2145.             }
  2146.         }
  2147.         }
  2148.  
  2149.         if (raisewin) {
  2150.         XRaiseWindow (dpy, raisewin);
  2151.         XWarpPointer (dpy, None, iconwin, 0,0,0,0, 5, 5);
  2152.         } else {
  2153.         XBell (dpy, 0);
  2154.         }
  2155.     }
  2156.     break;
  2157.     
  2158.     case F_WARPRING:
  2159.     switch (action[0]) {
  2160.       case 'n':
  2161.         WarpAlongRing (&eventp->xbutton, True);
  2162.         break;
  2163.       case 'p':
  2164.         WarpAlongRing (&eventp->xbutton, False);
  2165.         break;
  2166.       default:
  2167.         XBell (dpy, 0);
  2168.         break;
  2169.     }
  2170.     break;
  2171.  
  2172.     case F_FILE:
  2173.     action = ExpandFilename(action);
  2174.     fd = open(action, 0);
  2175.     if (fd >= 0)
  2176.     {
  2177.         count = read(fd, buff, MAX_FILE_SIZE - 1);
  2178.         if (count > 0)
  2179.         XStoreBytes(dpy, buff, count);
  2180.  
  2181.         close(fd);
  2182.     }
  2183.     else
  2184.     {
  2185.         fprintf (stderr, "%s:  unable to open file \"%s\"\n", 
  2186.              ProgramName, action);
  2187.     }
  2188.     break;
  2189.  
  2190.     case F_REFRESH:
  2191.     {
  2192.         XSetWindowAttributes attributes;
  2193.         unsigned long valuemask;
  2194.  
  2195.         valuemask = (CWBackPixel | CWBackingStore | CWSaveUnder);
  2196.         attributes.background_pixel = Scr->Black;
  2197.         attributes.backing_store = NotUseful;
  2198.         attributes.save_under = False;
  2199.         w = XCreateWindow (dpy, Scr->Root, 0, 0,
  2200.                    (unsigned int) Scr->MyDisplayWidth,
  2201.                    (unsigned int) Scr->MyDisplayHeight,
  2202.                    (unsigned int) 0,
  2203.                    CopyFromParent, (unsigned int) CopyFromParent,
  2204.                    (Visual *) CopyFromParent, valuemask,
  2205.                    &attributes);
  2206.         XMapWindow (dpy, w);
  2207.         XDestroyWindow (dpy, w);
  2208.         XFlush (dpy);
  2209.     }
  2210.     break;
  2211.  
  2212.     case F_WINREFRESH:
  2213.     if (DeferExecution(context, func, Scr->SelectCursor))
  2214.         return TRUE;
  2215.  
  2216.     if (context == C_ICON && tmp_win->icon_w)
  2217.         w = XCreateSimpleWindow(dpy, tmp_win->icon_w,
  2218.         0, 0, 9999, 9999, 0, Scr->Black, Scr->Black);
  2219.     else
  2220.         w = XCreateSimpleWindow(dpy, tmp_win->frame,
  2221.         0, 0, 9999, 9999, 0, Scr->Black, Scr->Black);
  2222.  
  2223.     XMapWindow(dpy, w);
  2224.     XDestroyWindow(dpy, w);
  2225.     XFlush(dpy);
  2226.     break;
  2227.  
  2228.     case F_QUIT:
  2229.     Done();
  2230.     break;
  2231.     }
  2232.  
  2233.     if (ButtonPressed == -1) XUngrabPointer(dpy, CurrentTime);
  2234.     return do_next_action;
  2235. }
  2236.  
  2237.  
  2238.  
  2239. /***********************************************************************
  2240.  *
  2241.  *  Procedure:
  2242.  *    DeferExecution - defer the execution of a function to the
  2243.  *        next button press if the context is C_ROOT
  2244.  *
  2245.  *  Inputs:
  2246.  *    context    - the context in which the mouse button was pressed
  2247.  *    func    - the function to defer
  2248.  *    cursor    - the cursor to display while waiting
  2249.  *
  2250.  ***********************************************************************
  2251.  */
  2252.  
  2253. int
  2254. DeferExecution(context, func, cursor)
  2255. int context, func;
  2256. Cursor cursor;
  2257. {
  2258.   if (context == C_ROOT)
  2259.     {
  2260.     LastCursor = cursor;
  2261.     XGrabPointer(dpy, Scr->Root, True,
  2262.         ButtonPressMask | ButtonReleaseMask,
  2263.         GrabModeAsync, GrabModeAsync,
  2264.         Scr->Root, cursor, CurrentTime);
  2265.  
  2266.     RootFunction = func;
  2267.  
  2268.     return (TRUE);
  2269.     }
  2270.     
  2271.     return (FALSE);
  2272. }
  2273.  
  2274.  
  2275.  
  2276. /***********************************************************************
  2277.  *
  2278.  *  Procedure:
  2279.  *    ReGrab - regrab the pointer with the LastCursor;
  2280.  *
  2281.  ***********************************************************************
  2282.  */
  2283.  
  2284. ReGrab()
  2285. {
  2286.     XGrabPointer(dpy, Scr->Root, True,
  2287.     ButtonPressMask | ButtonReleaseMask,
  2288.     GrabModeAsync, GrabModeAsync,
  2289.     Scr->Root, LastCursor, CurrentTime);
  2290. }
  2291.  
  2292.  
  2293.  
  2294. /***********************************************************************
  2295.  *
  2296.  *  Procedure:
  2297.  *    NeedToDefer - checks each function in the list to see if it
  2298.  *        is one that needs to be defered.
  2299.  *
  2300.  *  Inputs:
  2301.  *    root    - the menu root to check
  2302.  *
  2303.  ***********************************************************************
  2304.  */
  2305.  
  2306. NeedToDefer(root)
  2307. MenuRoot *root;
  2308. {
  2309.     MenuItem *mitem;
  2310.  
  2311.     for (mitem = root->first; mitem != NULL; mitem = mitem->next)
  2312.     {
  2313.     switch (mitem->func)
  2314.     {
  2315.     case F_IDENTIFY:
  2316.     case F_RESIZE:
  2317.     case F_MOVE:
  2318.     case F_FORCEMOVE:
  2319.     case F_DEICONIFY:
  2320.     case F_ICONIFY:
  2321.     case F_RAISELOWER:
  2322.     case F_RAISE:
  2323.     case F_LOWER:
  2324.     case F_FOCUS:
  2325.     case F_DESTROY:
  2326.     case F_WINREFRESH:
  2327.     case F_ZOOM:
  2328.     case F_FULLZOOM:
  2329.     case F_HORIZOOM:
  2330.         case F_RIGHTZOOM:
  2331.         case F_LEFTZOOM:
  2332.         case F_TOPZOOM:
  2333.         case F_BOTTOMZOOM:
  2334.     case F_AUTORAISE:
  2335.         return TRUE;
  2336.     }
  2337.     }
  2338.     return FALSE;
  2339. }
  2340.  
  2341.  
  2342.  
  2343. /***********************************************************************
  2344.  *
  2345.  *  Procedure:
  2346.  *    Execute - execute the string by /bin/sh
  2347.  *
  2348.  *  Inputs:
  2349.  *    s    - the string containing the command
  2350.  *
  2351.  ***********************************************************************
  2352.  */
  2353.  
  2354. void
  2355. Execute(s)
  2356.     char *s;
  2357. {
  2358.     static char buf[256];
  2359.     char *ds = DisplayString (dpy);
  2360.     char *colon, *dot1;
  2361.     char oldDisplay[256];
  2362.     char *doisplay;
  2363.     int restorevar = 0;
  2364.  
  2365.     oldDisplay[0] = '\0';
  2366.     doisplay=getenv("DISPLAY");
  2367.     if (doisplay)
  2368.     strcpy (oldDisplay, doisplay);
  2369.  
  2370.     /*
  2371.      * Build a display string using the current screen number, so that
  2372.      * X programs which get fired up from a menu come up on the screen
  2373.      * that they were invoked from, unless specifically overridden on
  2374.      * their command line.
  2375.      */
  2376.     colon = rindex (ds, ':');
  2377.     if (colon) {            /* if host[:]:dpy */
  2378.     strcpy (buf, "DISPLAY=");
  2379.     strcat (buf, ds);
  2380.     colon = buf + 8 + (colon - ds);    /* use version in buf */
  2381.     dot1 = index (colon, '.');    /* first period after colon */
  2382.     if (!dot1) dot1 = colon + strlen (colon);  /* if not there, append */
  2383.     (void) sprintf (dot1, ".%d", Scr->screen);
  2384.     putenv (buf);
  2385.     restorevar = 1;
  2386.     }
  2387.  
  2388.     (void) system (s);
  2389.  
  2390.     if (restorevar) {        /* why bother? */
  2391.     (void) sprintf (buf, "DISPLAY=%s", oldDisplay);
  2392.     putenv (buf);
  2393.     }
  2394. }
  2395.  
  2396.  
  2397.  
  2398. /***********************************************************************
  2399.  *
  2400.  *  Procedure:
  2401.  *    FocusOnRoot - put input focus on the root window
  2402.  *
  2403.  ***********************************************************************
  2404.  */
  2405.  
  2406. void
  2407. FocusOnRoot()
  2408. {
  2409.     SetFocus ((TwmWindow *) NULL, LastTimestamp());
  2410.     if (Scr->Focus != NULL)
  2411.     {
  2412.     SetBorder (Scr->Focus, False);
  2413.     if (Scr->Focus->hilite_w) XUnmapWindow (dpy, Scr->Focus->hilite_w);
  2414.     }
  2415.     InstallWindowColormaps(0, &Scr->TwmRoot);
  2416.     Scr->Focus = NULL;
  2417.     Scr->FocusRoot = TRUE;
  2418. }
  2419.  
  2420. DeIconify(tmp_win)
  2421. TwmWindow *tmp_win;
  2422. {
  2423.     TwmWindow *t;
  2424.  
  2425.     /* de-iconify the main window */
  2426.     if (tmp_win->icon)
  2427.     {
  2428.     if (tmp_win->icon_on)
  2429.         Zoom(tmp_win->icon_w, tmp_win->frame);
  2430.     else if (tmp_win->group != NULL)
  2431.     {
  2432.         for (t = Scr->TwmRoot.next; t != NULL; t = t->next)
  2433.         {
  2434.         if (tmp_win->group == t->w && t->icon_on)
  2435.         {
  2436.             Zoom(t->icon_w, tmp_win->frame);
  2437.             break;
  2438.         }
  2439.         }
  2440.     }
  2441.     }
  2442.  
  2443.     XMapWindow(dpy, tmp_win->w);
  2444.     tmp_win->mapped = TRUE;
  2445.     if (Scr->NoRaiseDeicon)
  2446.     XMapWindow(dpy, tmp_win->frame);
  2447.     else
  2448.     XMapRaised(dpy, tmp_win->frame);
  2449.     SetMapStateProp(tmp_win, NormalState);
  2450.  
  2451.     if (tmp_win->icon_w) {
  2452.     XUnmapWindow(dpy, tmp_win->icon_w);
  2453.     IconDown (tmp_win);
  2454.     }
  2455.     if (tmp_win->list)
  2456.     XUnmapWindow(dpy, tmp_win->list->icon);
  2457.     if ((Scr->WarpCursor ||
  2458.      LookInList(Scr->WarpCursorL, tmp_win->full_name, &tmp_win->class)) &&
  2459.     tmp_win->icon)
  2460.       WarpToWindow (tmp_win);
  2461.     tmp_win->icon = FALSE;
  2462.     tmp_win->icon_on = FALSE;
  2463.  
  2464.  
  2465.     /* now de-iconify transients */
  2466.     for (t = Scr->TwmRoot.next; t != NULL; t = t->next)
  2467.     {
  2468.       if (t->transient && t->transientfor == tmp_win->w)
  2469.         {
  2470.           if (t->icon_on)
  2471.         Zoom(t->icon_w, t->frame);
  2472.           else
  2473.         Zoom(tmp_win->icon_w, t->frame);
  2474.           
  2475.           XMapWindow(dpy, t->w);
  2476.           t->mapped = TRUE;
  2477.           if (Scr->NoRaiseDeicon)
  2478.         XMapWindow(dpy, t->frame);
  2479.           else
  2480.         XMapRaised(dpy, t->frame);
  2481.           SetMapStateProp(t, NormalState);
  2482.           
  2483.           if (t->icon_w) {
  2484.         XUnmapWindow(dpy, t->icon_w);
  2485.         IconDown (t);
  2486.           }
  2487.           if (t->list) XUnmapWindow(dpy, t->list->icon);
  2488.           t->icon = FALSE;
  2489.           t->icon_on = FALSE;
  2490.         }
  2491.     }
  2492.     
  2493.     XSync (dpy, 0);
  2494. }
  2495.  
  2496.  
  2497.  
  2498. Iconify(tmp_win, def_x, def_y)
  2499. TwmWindow *tmp_win;
  2500. int def_x, def_y;
  2501. {
  2502.     TwmWindow *t;
  2503.     int iconify;
  2504.     XWindowAttributes winattrs;
  2505.     unsigned long eventMask;
  2506.  
  2507.     iconify = ((!tmp_win->iconify_by_unmapping) || tmp_win->transient);
  2508.     if (iconify)
  2509.     {
  2510.     if (tmp_win->icon_w == NULL)
  2511.         CreateIconWindow(tmp_win, def_x, def_y);
  2512.     else
  2513.         IconUp(tmp_win);
  2514.     XMapRaised(dpy, tmp_win->icon_w);
  2515.     }
  2516.     if (tmp_win->list)
  2517.     XMapWindow(dpy, tmp_win->list->icon);
  2518.  
  2519.     XGetWindowAttributes(dpy, tmp_win->w, &winattrs);
  2520.     eventMask = winattrs.your_event_mask;
  2521.  
  2522.     /* iconify transients first */
  2523.     for (t = Scr->TwmRoot.next; t != NULL; t = t->next)
  2524.       {
  2525.     if (t->transient && t->transientfor == tmp_win->w)
  2526.       {
  2527.         if (iconify)
  2528.           {
  2529.         if (t->icon_on)
  2530.             Zoom(t->icon_w, tmp_win->icon_w);
  2531.         else
  2532.           Zoom(t->frame, tmp_win->icon_w);
  2533.           }
  2534.         
  2535.         /*
  2536.          * Prevent the receipt of an UnmapNotify, since that would
  2537.          * cause a transition to the Withdrawn state.
  2538.          */
  2539.         t->mapped = FALSE;
  2540.         XSelectInput(dpy, t->w, eventMask & ~StructureNotifyMask);
  2541.         XUnmapWindow(dpy, t->w);
  2542.         XSelectInput(dpy, t->w, eventMask);
  2543.         XUnmapWindow(dpy, t->frame);
  2544.         if (t->icon_w)
  2545.           XUnmapWindow(dpy, t->icon_w);
  2546.         SetMapStateProp(t, IconicState);
  2547.         SetBorder (t, False);
  2548.         if (t == Scr->Focus)
  2549.           {
  2550.         SetFocus ((TwmWindow *) NULL, LastTimestamp());
  2551.         Scr->Focus = NULL;
  2552.         Scr->FocusRoot = TRUE;
  2553.           }
  2554.         if (t->list) XMapWindow(dpy, t->list->icon);
  2555.         t->icon = TRUE;
  2556.         t->icon_on = FALSE;
  2557.       }
  2558.       } 
  2559.     
  2560.     if (iconify)
  2561.     Zoom(tmp_win->frame, tmp_win->icon_w);
  2562.  
  2563.     /*
  2564.      * Prevent the receipt of an UnmapNotify, since that would
  2565.      * cause a transition to the Withdrawn state.
  2566.      */
  2567.     tmp_win->mapped = FALSE;
  2568.     XSelectInput(dpy, tmp_win->w, eventMask & ~StructureNotifyMask);
  2569.     XUnmapWindow(dpy, tmp_win->w);
  2570.     XSelectInput(dpy, tmp_win->w, eventMask);
  2571.     XUnmapWindow(dpy, tmp_win->frame);
  2572.     SetMapStateProp(tmp_win, IconicState);
  2573.  
  2574.     SetBorder (tmp_win, False);
  2575.     if (tmp_win == Scr->Focus)
  2576.     {
  2577.     SetFocus ((TwmWindow *) NULL, LastTimestamp());
  2578.     Scr->Focus = NULL;
  2579.     Scr->FocusRoot = TRUE;
  2580.     }
  2581.     tmp_win->icon = TRUE;
  2582.     if (iconify)
  2583.     tmp_win->icon_on = TRUE;
  2584.     else
  2585.     tmp_win->icon_on = FALSE;
  2586.     XSync (dpy, 0);
  2587. }
  2588.  
  2589.  
  2590.  
  2591. static void Identify (t)
  2592. TwmWindow *t;
  2593. {
  2594.     int i, n, twidth, width, height;
  2595.     int x, y;
  2596.     unsigned int wwidth, wheight, bw, depth;
  2597.     Window junk;
  2598.     int px, py, dummy;
  2599.     unsigned udummy;
  2600.  
  2601.     n = 0;
  2602.     (void) sprintf(Info[n++], "Twm version:  %s", Version);
  2603.     Info[n++][0] = '\0';
  2604.  
  2605.     if (t) {
  2606.     XGetGeometry (dpy, t->w, &JunkRoot, &JunkX, &JunkY,
  2607.               &wwidth, &wheight, &bw, &depth);
  2608.     (void) XTranslateCoordinates (dpy, t->w, Scr->Root, 0, 0,
  2609.                       &x, &y, &junk);
  2610.     (void) sprintf(Info[n++], "Name             = \"%s\"", t->full_name);
  2611.     (void) sprintf(Info[n++], "Class.res_name   = \"%s\"", t->class.res_name);
  2612.     (void) sprintf(Info[n++], "Class.res_class  = \"%s\"", t->class.res_class);
  2613.     Info[n++][0] = '\0';
  2614.     (void) sprintf(Info[n++], "Geometry/root    = %dx%d+%d+%d", wwidth, wheight,
  2615.         x, y);
  2616.     (void) sprintf(Info[n++], "Border width     = %d", bw);
  2617.     (void) sprintf(Info[n++], "Depth            = %d", depth);
  2618.     }
  2619.  
  2620.     Info[n++][0] = '\0';
  2621.     (void) sprintf(Info[n++], "Click to dismiss....");
  2622.  
  2623.     /* figure out the width and height of the info window */
  2624.     height = n * (Scr->DefaultFont.height+2);
  2625.     width = 1;
  2626.     for (i = 0; i < n; i++)
  2627.     {
  2628.     twidth = XTextWidth(Scr->DefaultFont.font, Info[i],
  2629.         strlen(Info[i]));
  2630.     if (twidth > width)
  2631.         width = twidth;
  2632.     }
  2633.     if (InfoLines) XUnmapWindow(dpy, Scr->InfoWindow);
  2634.  
  2635.     width += 10;        /* some padding */
  2636.     if (XQueryPointer (dpy, Scr->Root, &JunkRoot, &JunkChild, &px, &py,
  2637.                &dummy, &dummy, &udummy)) {
  2638.     px -= (width / 2);
  2639.     py -= (height / 3);
  2640.     if (px + width + BW2 >= Scr->MyDisplayWidth) 
  2641.       px = Scr->MyDisplayWidth - width - BW2;
  2642.     if (py + height + BW2 >= Scr->MyDisplayHeight) 
  2643.       py = Scr->MyDisplayHeight - height - BW2;
  2644.     if (px < 0) px = 0;
  2645.     if (py < 0) py = 0;
  2646.     } else {
  2647.     px = py = 0;
  2648.     }
  2649.     XMoveResizeWindow(dpy, Scr->InfoWindow, px, py, width, height);
  2650.     XMapRaised(dpy, Scr->InfoWindow); 
  2651.     InfoLines = n;
  2652. }
  2653.  
  2654.  
  2655.  
  2656. SetMapStateProp(tmp_win, state)
  2657. TwmWindow *tmp_win;
  2658. int state;
  2659. {
  2660.     unsigned long data[2];        /* "suggested" by ICCCM version 1 */
  2661.   
  2662.     data[0] = (unsigned long) state;
  2663.     data[1] = (unsigned long) (tmp_win->iconify_by_unmapping ? None : 
  2664.                tmp_win->icon_w);
  2665.  
  2666.     XChangeProperty (dpy, tmp_win->w, _XA_WM_STATE, _XA_WM_STATE, 32, 
  2667.          PropModeReplace, (unsigned char *) data, 2);
  2668. }
  2669.  
  2670.  
  2671.  
  2672. Bool GetWMState (w, statep, iwp)
  2673.     Window w;
  2674.     int *statep;
  2675.     Window *iwp;
  2676. {
  2677.     Atom actual_type;
  2678.     int actual_format;
  2679.     unsigned long nitems, bytesafter;
  2680.     unsigned long *datap = NULL;
  2681.     Bool retval = False;
  2682.  
  2683.     if (XGetWindowProperty (dpy, w, _XA_WM_STATE, 0L, 2L, False, _XA_WM_STATE,
  2684.                 &actual_type, &actual_format, &nitems, &bytesafter,
  2685.                 (unsigned char **) &datap) != Success || !datap)
  2686.       return False;
  2687.  
  2688.     if (nitems <= 2) {            /* "suggested" by ICCCM version 1 */
  2689.     *statep = (int) datap[0];
  2690.     *iwp = (Window) datap[1];
  2691.     retval = True;
  2692.     }
  2693.  
  2694.     XFree ((char *) datap);
  2695.     return retval;
  2696. }
  2697.  
  2698.  
  2699.  
  2700. WarpToScreen (n, inc)
  2701.     int n, inc;
  2702. {
  2703.     Window dumwin;
  2704.     int x, y, dumint;
  2705.     unsigned int dummask;
  2706.     ScreenInfo *newscr = NULL;
  2707.  
  2708.     while (!newscr) {
  2709.                     /* wrap around */
  2710.     if (n < 0) 
  2711.       n = NumScreens - 1;
  2712.     else if (n >= NumScreens)
  2713.       n = 0;
  2714.  
  2715.     newscr = ScreenList[n];
  2716.     if (!newscr) {            /* make sure screen is managed */
  2717.         if (inc) {            /* walk around the list */
  2718.         n += inc;
  2719.         continue;
  2720.         }
  2721.         fprintf (stderr, "%s:  unable to warp to unmanaged screen %d\n", 
  2722.              ProgramName, n);
  2723.         XBell (dpy, 0);
  2724.         return;
  2725.     }
  2726.     }
  2727.  
  2728.     if (Scr->screen == n) return;    /* already on that screen */
  2729.  
  2730.     PreviousScreen = Scr->screen;
  2731.     XQueryPointer (dpy, Scr->Root, &dumwin, &dumwin, &x, &y,
  2732.            &dumint, &dumint, &dummask);
  2733.  
  2734.     XWarpPointer (dpy, None, newscr->Root, 0, 0, 0, 0, x, y);
  2735.     return;
  2736. }
  2737.  
  2738.  
  2739.  
  2740.  
  2741. /*
  2742.  * BumpWindowColormap - rotate our internal copy of WM_COLORMAP_WINDOWS
  2743.  */
  2744.  
  2745. BumpWindowColormap (tmp, inc)
  2746.     TwmWindow *tmp;
  2747.     int inc;
  2748. {
  2749.     int i, j, previously_installed;
  2750.     ColormapWindow **cwins;
  2751.  
  2752.     if (!tmp) return;
  2753.  
  2754.     if (inc && tmp->cmaps.number_cwins > 0) {
  2755.     cwins = (ColormapWindow **) malloc(sizeof(ColormapWindow *)*
  2756.                        tmp->cmaps.number_cwins);
  2757.     if (cwins) {        
  2758.         if (previously_installed =
  2759.         /* SUPPRESS 560 */(Scr->cmapInfo.cmaps == &tmp->cmaps &&
  2760.             tmp->cmaps.number_cwins)) {
  2761.         for (i = tmp->cmaps.number_cwins; i-- > 0; )
  2762.             tmp->cmaps.cwins[i]->colormap->state = 0;
  2763.         }
  2764.  
  2765.         for (i = 0; i < tmp->cmaps.number_cwins; i++) {
  2766.         j = i - inc;
  2767.         if (j >= tmp->cmaps.number_cwins)
  2768.             j -= tmp->cmaps.number_cwins;
  2769.         else if (j < 0)
  2770.             j += tmp->cmaps.number_cwins;
  2771.         cwins[j] = tmp->cmaps.cwins[i];
  2772.         }
  2773.  
  2774.         free((char *) tmp->cmaps.cwins);
  2775.  
  2776.         tmp->cmaps.cwins = cwins;
  2777.  
  2778.         if (tmp->cmaps.number_cwins > 1)
  2779.         bzero (tmp->cmaps.scoreboard, 
  2780.                ColormapsScoreboardLength(&tmp->cmaps));
  2781.  
  2782.         if (previously_installed)
  2783.         InstallWindowColormaps(PropertyNotify, (TwmWindow *) NULL);
  2784.     }
  2785.     } else
  2786.     FetchWmColormapWindows (tmp);
  2787. }
  2788.  
  2789.  
  2790.  
  2791. HideIconManager ()
  2792. {
  2793.     SetMapStateProp (Scr->iconmgr.twm_win, WithdrawnState);
  2794.     XUnmapWindow(dpy, Scr->iconmgr.twm_win->frame);
  2795.     if (Scr->iconmgr.twm_win->icon_w)
  2796.       XUnmapWindow (dpy, Scr->iconmgr.twm_win->icon_w);
  2797.     Scr->iconmgr.twm_win->mapped = FALSE;
  2798.     Scr->iconmgr.twm_win->icon = TRUE;
  2799. }
  2800.  
  2801.  
  2802.  
  2803.  
  2804. SetBorder (tmp, onoroff)
  2805.     TwmWindow *tmp;
  2806.     Bool onoroff;
  2807. {
  2808.     if (tmp->highlight) {
  2809.     if (onoroff) {
  2810.         XSetWindowBorder (dpy, tmp->frame, tmp->border);
  2811.         if (tmp->title_w) 
  2812.           XSetWindowBorder (dpy, tmp->title_w, tmp->border);
  2813.     } else {
  2814.         XSetWindowBorderPixmap (dpy, tmp->frame, tmp->gray);
  2815.         if (tmp->title_w) 
  2816.           XSetWindowBorderPixmap (dpy, tmp->title_w, tmp->gray);
  2817.     }
  2818.     }
  2819. }
  2820.  
  2821.  
  2822.  
  2823. DestroyMenu (menu)
  2824.     MenuRoot *menu;
  2825. {
  2826.     MenuItem *item;
  2827.  
  2828.     if (menu->w) {
  2829.     XDeleteContext (dpy, menu->w, MenuContext);
  2830.     XDeleteContext (dpy, menu->w, ScreenContext);
  2831.     if (Scr->Shadow) XDestroyWindow (dpy, menu->shadow);
  2832.     XDestroyWindow(dpy, menu->w);
  2833.     }
  2834.  
  2835.     for (item = menu->first; item; ) {
  2836.     MenuItem *tmp = item;
  2837.     item = item->next;
  2838.     free ((char *) tmp);
  2839.     }
  2840. }
  2841.  
  2842.  
  2843.  
  2844. /*
  2845.  * warping routines
  2846.  */
  2847. void WarpAlongRing (ev, forward)
  2848.     XButtonEvent *ev;
  2849.     Bool forward;
  2850. {
  2851.     TwmWindow *r, *head;
  2852.  
  2853.     if (Scr->RingLeader)
  2854.       head = Scr->RingLeader;
  2855.     else if (!(head = Scr->Ring)) 
  2856.       return;
  2857.  
  2858.     if (forward) {
  2859.     for (r = head->ring.next; r != head; r = r->ring.next) {
  2860.         if (!r || r->mapped) break;
  2861.     }
  2862.     } else {
  2863.     for (r = head->ring.prev; r != head; r = r->ring.prev) {
  2864.         if (!r || r->mapped) break;
  2865.     }
  2866.     }
  2867.  
  2868.     if (r && r != head) {
  2869.     TwmWindow *p = Scr->RingLeader, *t;
  2870.  
  2871.     Scr->RingLeader = r;
  2872.     WarpToWindow (r);
  2873.  
  2874.     if (p && p->mapped &&
  2875.         XFindContext (dpy, ev->window, TwmContext, (caddr_t *)&t) == XCSUCCESS &&
  2876.         p == t) {
  2877.         p->ring.cursor_valid = True;
  2878.         p->ring.curs_x = ev->x_root - t->frame_x;
  2879.         p->ring.curs_y = ev->y_root - t->frame_y;
  2880.         if (p->ring.curs_x < -p->frame_bw || 
  2881.         p->ring.curs_x >= p->frame_width + p->frame_bw ||
  2882.         p->ring.curs_y < -p->frame_bw || 
  2883.         p->ring.curs_y >= p->frame_height + p->frame_bw) {
  2884.         /* somehow out of window */
  2885.         p->ring.curs_x = p->frame_width / 2;
  2886.         p->ring.curs_y = p->frame_height / 2;
  2887.         }
  2888.     }
  2889.     }
  2890. }
  2891.  
  2892.  
  2893.  
  2894. void WarpToWindow (t)
  2895.     TwmWindow *t;
  2896. {
  2897.     int x, y;
  2898.  
  2899.     if (t->auto_raise || !Scr->NoRaiseWarp) AutoRaiseWindow (t);
  2900.     if (t->ring.cursor_valid) {
  2901.     x = t->ring.curs_x;
  2902.     y = t->ring.curs_y;
  2903.     } else {
  2904.     x = t->frame_width / 2;
  2905.     y = t->frame_height / 2;
  2906.     }
  2907.     XWarpPointer (dpy, None, t->frame, 0, 0, 0, 0, x, y);
  2908. }
  2909.  
  2910.  
  2911.  
  2912.  
  2913. /*
  2914.  * ICCCM Client Messages - Section 4.2.8 of the ICCCM dictates that all
  2915.  * client messages will have the following form:
  2916.  *
  2917.  *     event type    ClientMessage
  2918.  *     message type    _XA_WM_PROTOCOLS
  2919.  *     window        tmp->w
  2920.  *     format        32
  2921.  *     data[0]        message atom
  2922.  *     data[1]        time stamp
  2923.  */
  2924. static void send_clientmessage (w, a, timestamp)
  2925.     Window w;
  2926.     Atom a;
  2927.     Time timestamp;
  2928. {
  2929.     XClientMessageEvent ev;
  2930.  
  2931.     ev.type = ClientMessage;
  2932.     ev.window = w;
  2933.     ev.message_type = _XA_WM_PROTOCOLS;
  2934.     ev.format = 32;
  2935.     ev.data.l[0] = a;
  2936.     ev.data.l[1] = timestamp;
  2937.     XSendEvent (dpy, w, False, 0L, (XEvent *) &ev);
  2938. }
  2939.  
  2940. SendDeleteWindowMessage (tmp, timestamp)
  2941.     TwmWindow *tmp;
  2942.     Time timestamp;
  2943. {
  2944.     send_clientmessage (tmp->w, _XA_WM_DELETE_WINDOW, timestamp);
  2945. }
  2946.  
  2947. SendSaveYourselfMessage (tmp, timestamp)
  2948.     TwmWindow *tmp;
  2949.     Time timestamp;
  2950. {
  2951.     send_clientmessage (tmp->w, _XA_WM_SAVE_YOURSELF, timestamp);
  2952. }
  2953.  
  2954.  
  2955. SendTakeFocusMessage (tmp, timestamp)
  2956.     TwmWindow *tmp;
  2957.     Time timestamp;
  2958. {
  2959.     send_clientmessage (tmp->w, _XA_WM_TAKE_FOCUS, timestamp);
  2960. }
  2961.